using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Tango.Editors
{
    /// <summary>
    /// Represents an undo/redo states provider base class.
    /// </summary>
    /// <seealso cref="Tango.Editors.IUndoRedoStatesProvider" />
    public abstract class UndoRedoStatesProviderBase : IUndoRedoStatesProvider
    {
        private IUndoRedoState _uncommittedState; //Holds the current undo state about to be committed.

        /// <summary>
        /// Occurs when an Undo/Redo state was executed.
        /// </summary>
        public event EventHandler<UndoRedoStateExecutedEventArgs> StateExecuted;

        /// <summary>
        /// Gets the undo states.
        /// </summary>
        public Stack<IUndoRedoState> UndoStates { get; protected set; }

        /// <summary>
        /// Gets the redo states.
        /// </summary>
        public Stack<IUndoRedoState> RedoStates { get; protected set; }

        /// <summary>
        /// Gets a value indicating whether this instance can undo.
        /// </summary>
        public bool CanUndo
        {
            get
            {
                return UndoStates.Count > 0;
            }
        }

        /// <summary>
        /// Gets a value indicating whether this instance can redo.
        /// </summary>
        public bool CanRedo
        {
            get
            {
                return RedoStates.Count > 0;
            }
        }


        /// <summary>
        /// Initializes a new instance of the <see cref="UndoRedoStatesProviderBase"/> class.
        /// </summary>
        public UndoRedoStatesProviderBase()
        {
            UndoStates = new Stack<IUndoRedoState>();
            RedoStates = new Stack<IUndoRedoState>();
        }


        /// <summary>
        /// Prepares the state of the undo.
        /// </summary>
        public virtual void PrepareUndoState()
        {
            RedoStates.Clear();
            _uncommittedState = CreateUndoRedoState();
        }

        /// <summary>
        /// Commits the state created by <see cref="PrepareUndoState" />.
        /// </summary>
        public void CommitUndoState()
        {
            if (_uncommittedState != null)
            {
                UndoStates.Push(_uncommittedState);
                _uncommittedState = null;
            }
        }

        /// <summary>
        /// Creates the a new undo/redo state.
        /// </summary>
        /// <returns></returns>
        public abstract IUndoRedoState CreateUndoRedoState();

        /// <summary>
        /// Executes the an undo/redo state.
        /// </summary>
        /// <param name="state">The state.</param>
        public abstract void ExecuteState(IUndoRedoState state);

        /// <summary>
        /// Performs an undo operation.
        /// </summary>
        public virtual void Undo()
        {
            if (UndoStates.Count > 0)
            {
                var state = UndoStates.Pop();

                var redoState = CreateUndoRedoState();

                ExecuteState(state);

                OnStateExecuted(new UndoRedoStateExecutedEventArgs() { Mode = UndoRedoStateMode.Undo, State = state });

                RedoStates.Push(redoState);
            }
        }

        /// <summary>
        /// Performs a redo operation.
        /// </summary>
        public virtual void Redo()
        {
            if (RedoStates.Count > 0)
            {
                var state = RedoStates.Pop();

                var undoState = CreateUndoRedoState();

                ExecuteState(state);

                OnStateExecuted(new UndoRedoStateExecutedEventArgs() { Mode = UndoRedoStateMode.Redo, State = state });

                UndoStates.Push(undoState);
            }
        }

        /// <summary>
        /// Raises the <see cref="E:StateExecuted" /> event.
        /// </summary>
        /// <param name="e">The <see cref="UndoRedoStateExecutedEventArgs"/> instance containing the event data.</param>
        public virtual void OnStateExecuted(UndoRedoStateExecutedEventArgs e)
        {
            if (StateExecuted != null) StateExecuted(this, e);
        }

        /// <summary>
        /// Resets undo and redo states.
        /// </summary>
        public void Reset()
        {
            UndoStates.Clear();
            RedoStates.Clear();
        }
    }
}