Blog

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using Orcsune.Core.Extensions;

namespace Orcsune.Core.Builder {
    public class ChangeStack : IEnumerable {
        private Stack<SaveState> undoStack;
        private Stack<SaveState> redoStack;

        public SaveState top {
            get => undoStack == null || undoStack.Count == 0 ? default : undoStack.Peek();
        }

        public ChangeStack() {
            undoStack = new Stack<SaveState>();
            redoStack = new Stack<SaveState>();
        }
        public ChangeStack(Stack<SaveState> undo, Stack<SaveState> redo) {
            undoStack = undo.CopyStack<SaveState>();
            redoStack = redo.CopyStack<SaveState>();
        }

        public ChangeStack Copy() {
            return new ChangeStack(undoStack, redoStack);
        }

        public int undoStackCount { get => undoStack.Count; }
        public int redoStackCount { get => redoStack.Count; }

        public void Clear() {
            undoStack.Clear();
            redoStack.Clear();
        }

        public void DeleteTop() {
            undoStack.TryPop(out SaveState state);
        }

        public SaveState Top() {
            if (undoStack.Count > 0) { return undoStack.Peek(); }
            return null;
        }

        /// <summary>
        /// Same functionality as TryPushState except the redoStack
        /// is cleared if the new state is successfully placed on the
        /// undoStack.
        /// </summary>
        /// <param name="savable">Object to try and save.</param>
        /// <returns></returns>
        public bool PushNewInteraction(IChangeStackSavable savable) {
            bool success = TryPushUndoState(savable);
            if (success) {
                redoStack.Clear();
            }
            return success;
        }
        /// <summary>
        /// Adds a different savable to the ChangeStack.
        /// If the new save state is the same as the previous save state,
        /// then the new state is not saved and we return false.
        /// If the new save state is different from the previous state,
        /// then the new state is saved and we return true.
        /// </summary>
        /// <param name="savable">The object to try and save.</param>
        /// <returns>Bool describing whether a new state was added to the stack.</returns>
        public bool TryPushUndoState(IChangeStackSavable savable) {
            SaveState saveState = savable.ToSaveStateDefault();
            return TryPushUndoState(saveState);
        }
        public bool TryPushUndoState(SaveState saveState) {
            if (undoStack.Count > 0 && saveState.Equals(undoStack.Peek())) {
                return false;
            } else {
                undoStack.Push(saveState);
                return true;
            }
        }

        public bool ApplyTopUndo(IChangeStackSavable savable) {
            // Do nothing if nothing in undoStack
            if (undoStack.Count == 0) {
                return false;
            }
            // ONLY peek if only 1 thing left in stack
            // DO NOT place the undone thing on the redoStack.
            else if (undoStack.Count >= 1) {
                SaveState readState = undoStack.Peek();
                savable.FromSaveState(readState);
            }
            return true;
        }
        /// <summary>
        /// undoStack contains up to the CURRENT version of the
        /// savable. To undo, we must pop of that current version
        /// and deserialize from the new top of the stack.
        /// Make sure to pop the old top onto the redo stack.
        /// </summary>
        /// <param name="savable">Savable to modify to the old save state.</param>
        /// <returns></returns>
        public bool Undo(IChangeStackSavable savable) {
            // Do nothing if nothing in undoStack
            if (undoStack.Count == 0) {
                return false;
            }
            // ONLY peek if only 1 thing left in stack
            // DO NOT place the undone thing on the redoStack.
            else if (undoStack.Count == 1) {
                SaveState readState = undoStack.Peek();
                savable.FromSaveState(readState);
            }
            // Otherwise, do a normal undo:
            // pop, peek, change savable, add to redo stack
            else {
                SaveState oldTop = undoStack.Pop();
                SaveState readState = undoStack.Peek();
                savable.FromSaveState(readState);
                redoStack.Push(oldTop);
            }
            return true;
        }
        /// <summary>
        /// Redoes a previously undone action.
        /// </summary>
        /// <param name="savable">Savable to modify to the old save state.</param>
        /// <returns></returns>
        public bool Redo(IChangeStackSavable savable) {
            if (redoStack.Count == 0) {
                return false;
            }
            else {
                SaveState readState = redoStack.Pop();
                savable.FromSaveState(readState);
                // Can place directly on undo stack again
                undoStack.Push(readState);
            }
            return true;
        }

        public IEnumerator GetEnumerator()
        {
            return undoStack.GetEnumerator();
        }
    }
}