using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Tango.Core.Commands;
using Tango.SharedUI;

namespace Tango.Console
{
    /// <summary>
    /// Represents a command prompt console control view model.
    /// </summary>
    /// <seealso cref="Tango.SharedUI.ViewModel" />
    public class ConsoleControlVM : ViewModel
    {
        private int _historyIndex;
        private List<ConsoleSuggestion> _knownSuggestions;

        /// <summary>
        /// Occurs when a command is executing.
        /// </summary>
        public event EventHandler<ConsoleCommandExecutingEventArgs> CommandExecuting;

        /// <summary>
        /// Gets the commands history.
        /// </summary>
        public ObservableCollection<ConsoleCommand> Commands { get; private set; }

        private ConsoleCommand _currentCommand;
        /// <summary>
        /// Gets or sets the current command.
        /// </summary>
        public ConsoleCommand CurrentCommand
        {
            get { return _currentCommand; }
            set { _currentCommand = value; RaisePropertyChangedAuto(); }
        }

        private List<ConsoleSuggestion> _suggestions;
        /// <summary>
        /// Gets or sets the available auto complete suggestions.
        /// </summary>
        public List<ConsoleSuggestion> Suggestions
        {
            get { return _suggestions; }
            set { _suggestions = value; RaisePropertyChangedAuto(); }
        }

        /// <summary>
        /// Executes the current command.
        /// </summary>
        public RelayCommand ExecuteCommand { get; set; }

        /// <summary>
        /// Navigates down through the commands history.
        /// </summary>
        public RelayCommand HistoryDownCommand { get; set; }

        /// <summary>
        /// Navigates up through the commands history.
        /// </summary>
        public RelayCommand HistoryUpCommand { get; set; }

        /// <summary>
        /// Initializes a new instance of the <see cref="ConsoleControlVM"/> class.
        /// </summary>
        public ConsoleControlVM()
        {
            Commands = new ObservableCollection<ConsoleCommand>();
            CurrentCommand = new ConsoleCommand()
            {
                WorkingFolder = Environment.CurrentDirectory
            };

            ExecuteCommand = new RelayCommand(Execute);

            HistoryDownCommand = new RelayCommand(HistoryDown);
            HistoryUpCommand = new RelayCommand(HistoryUp);

            _knownSuggestions = new List<ConsoleSuggestion>(ConsoleDictionary.GetKnownCommands().Select(x => new ConsoleSuggestion()
            {
                Type = ConsoleSuggestionType.Command,
                Name = x.Name,
                Description = x.Description
            }));

            Suggestions = new List<ConsoleSuggestion>(_knownSuggestions);
        }

        private void HistoryUp()
        {
            if (_historyIndex > 0)
            {
                _historyIndex--;
                CreateNew(CurrentCommand.WorkingFolder, false, GetDistinctCommands()[_historyIndex].CommandText, true);
            }
        }

        private void HistoryDown()
        {
            if (_historyIndex < GetDistinctCommands().Count - 1)
            {
                _historyIndex++;
                CreateNew(CurrentCommand.WorkingFolder, false, GetDistinctCommands()[_historyIndex].CommandText, true);
            }
        }

        private void Execute()
        {
            if (CurrentCommand != null)
            {
                if (!CurrentCommand.CommandText.IsNotNullOrEmpty())
                {
                    CreateNew(CurrentCommand.WorkingFolder, true);
                    return;
                }

                if (CurrentCommand.CommandText.ToLower() == "clear")
                {
                    Clear();
                    return;
                }

                CurrentCommand.IsExecuting = true;

                ConsoleCommandExecutingEventArgs args = new ConsoleCommandExecutingEventArgs(CurrentCommand, (result) =>
                {
                    CurrentCommand.IsExecuting = false;
                    CurrentCommand.Output = result.Output;

                    CreateNew(result.WorkingFolder, true);

                    AppendSuggestions(result.Suggestions);
                });

                CommandExecuting?.Invoke(this, args);
            }
        }

        /// <summary>
        /// Concatenates the specified suggestions to the current suggestions.
        /// </summary>
        /// <param name="suggestions">The suggestions.</param>
        public void AppendSuggestions(List<ConsoleSuggestion> suggestions)
        {
            Suggestions = _knownSuggestions.Concat(suggestions).OrderBy(x => x.Name).ToList();
        }

        /// <summary>
        /// Clears the console.
        /// </summary>
        public void Clear()
        {
            Commands.Clear();
            CreateNew(CurrentCommand.WorkingFolder, false);
        }

        /// <summary>
        /// Clears and creates a new current command with the specified working folder.
        /// </summary>
        /// <param name="workingFolder">The working folder.</param>
        public void Clear(String workingFolder)
        {
            Commands.Clear();
            CreateNew(workingFolder, false);
        }

        private void CreateNew(String workingFolder, bool pushCurrent, String commandText = null, bool fromHistory = false)
        {
            if (pushCurrent)
            {
                Commands.Add(CurrentCommand);
                _historyIndex = GetDistinctCommands().Count;
            }

            CurrentCommand = new ConsoleCommand()
            {
                WorkingFolder = workingFolder != null ? workingFolder : CurrentCommand.WorkingFolder,
                CommandText = commandText,
                IsFromHistory = fromHistory
            };
        }

        private List<ConsoleCommand> GetDistinctCommands()
        {
            return Commands.Where(x => !x.IsFromHistory).ToList();
        }
    }
}