using System;
using System.Collections.Generic;

namespace codelanguage;

/// <summary>Classification of an edit, used for typing coalescing.</summary>
public enum EditKind
{
    /// <summary>Anything else (paste, enter, block indent, replace…).</summary>
    Other,
    /// <summary>A single character typed at the caret.</summary>
    InsertChar,
    /// <summary>A single character removed before the caret (Backspace).</summary>
    DeleteBackward,
    /// <summary>A single character removed after the caret (Delete).</summary>
    DeleteForward,
}

/// <summary>Immutable snapshot of the buffer plus caret/selection state.</summary>
public sealed record EditorSnapshot(
    string Text,
    int CaretLine,
    int CaretColumn,
    bool HasSelection,
    int SelStartLine,
    int SelStartCol,
    int SelEndLine,
    int SelEndCol);

/// <summary>
/// Snapshot-based undo/redo history with typing coalescing: consecutive single
/// character inserts (or single character backspaces/deletes) performed one
/// after another collapse into one undo step, so undoing after typing a word
/// reverts the whole word instead of one letter.
/// </summary>
public sealed class UndoStack
{
    private const int MaxDepth = 200;

    private readonly List<EditorSnapshot> _undo = new();
    private readonly List<EditorSnapshot> _redo = new();

    private EditKind _mergeKind = EditKind.Other;
    private int _mergeLine;
    private int _mergeCol;
    private bool _hasMergeAnchor;

    public bool CanUndo => _undo.Count > 0;
    public bool CanRedo => _redo.Count > 0;
    public int UndoCount => _undo.Count;
    public int RedoCount => _redo.Count;

    public void Clear()
    {
        _undo.Clear();
        _redo.Clear();
        ResetMerge();
    }

    /// <summary>
    /// Records the state from <em>before</em> an edit that was just applied.
    /// <paramref name="kind"/> plus the caret position after the edit decide
    /// whether this step merges into the previous one. Any new edit clears the
    /// redo stack.
    /// </summary>
    public void Push(EditorSnapshot before, EditKind kind, int caretLineAfter, int caretColumnAfter)
    {
        bool canMerge = _hasMergeAnchor
            && kind != EditKind.Other
            && kind == _mergeKind
            && !before.HasSelection
            && before.CaretLine == _mergeLine
            && before.CaretColumn == _mergeCol;

        if (!canMerge)
        {
            _undo.Add(before);
            if (_undo.Count > MaxDepth)
                _undo.RemoveAt(0);
        }

        _redo.Clear();

        if (kind == EditKind.Other)
        {
            ResetMerge();
        }
        else
        {
            _mergeKind = kind;
            _mergeLine = caretLineAfter;
            _mergeCol = caretColumnAfter;
            _hasMergeAnchor = true;
        }
    }

    /// <summary>
    /// Undoes the most recent step and returns the snapshot to restore, or null
    /// when history is empty. <paramref name="current"/> becomes the redo state.
    /// </summary>
    public EditorSnapshot? Undo(EditorSnapshot current)
    {
        if (_undo.Count == 0) return null;

        _redo.Add(current);
        var snapshot = _undo[^1];
        _undo.RemoveAt(_undo.Count - 1);
        ResetMerge();
        return snapshot;
    }

    /// <summary>
    /// Redoes the most recent undo and returns the snapshot to restore, or null
    /// when the redo stack is empty. <paramref name="current"/> becomes the undo state.
    /// </summary>
    public EditorSnapshot? Redo(EditorSnapshot current)
    {
        if (_redo.Count == 0) return null;

        _undo.Add(current);
        var snapshot = _redo[^1];
        _redo.RemoveAt(_redo.Count - 1);
        ResetMerge();
        return snapshot;
    }

    private void ResetMerge()
    {
        _mergeKind = EditKind.Other;
        _hasMergeAnchor = false;
        _mergeLine = 0;
        _mergeCol = 0;
    }
}