using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace codelanguage;

public class DebuggerService
{
    public event EventHandler<int>? BreakpointHit;
    public event EventHandler<DebuggerState>? StateChanged;
    public event EventHandler<string>? OutputMessage;

    private readonly Interpreter _interpreter;
    private bool _attached;
    private bool _paused;
    private Dictionary<string, HashSet<int>> _breakpoints = new();
    private HashSet<string> _disabledBreakpoints = new();
    private int _currentLine;
    private string _currentFile = "";
    private Stack<DebuggerFrame> _callStack = new();
    private List<string> _watches = new();
    private Dictionary<string, CraftValue> _locals = new();

    public bool IsAttached => _attached;
    public bool IsPaused => _paused;
    public int CurrentLine => _currentLine;
    public string CurrentFile => _currentFile;
    public IReadOnlyDictionary<string, HashSet<int>> Breakpoints => _breakpoints;

    public DebuggerService(Interpreter interpreter)
    {
        _interpreter = interpreter;
    }

    public void Attach()
    {
        _attached = true;
        _paused = false;
        StateChanged?.Invoke(this, new DebuggerState { IsRunning = !_paused, IsAttached = true });
    }

    public void Detach()
    {
        _attached = false;
        _paused = false;
        StateChanged?.Invoke(this, new DebuggerState { IsRunning = true, IsAttached = false });
    }

    public void Pause()
    {
        _paused = true;
        StateChanged?.Invoke(this, new DebuggerState { IsRunning = false, CurrentFile = _currentFile, CurrentLine = _currentLine });
    }

    public void Continue()
    {
        _paused = false;
        StateChanged?.Invoke(this, new DebuggerState { IsRunning = true });
    }

    public void StepOver()
    {
        _paused = false;
        StateChanged?.Invoke(this, new DebuggerState { IsRunning = true, StepMode = StepMode.StepOver });
    }

    public void StepInto()
    {
        _paused = false;
        StateChanged?.Invoke(this, new DebuggerState { IsRunning = true, StepMode = StepMode.StepInto });
    }

    public void StepOut()
    {
        _paused = false;
        StateChanged?.Invoke(this, new DebuggerState { IsRunning = true, StepMode = StepMode.StepOut });
    }

    public void ToggleBreakpoint(string file, int line)
    {
        if (string.IsNullOrEmpty(file)) return;
        if (!_breakpoints.ContainsKey(file)) _breakpoints[file] = new HashSet<int>();
        if (!_breakpoints[file].Add(line))
        {
            _breakpoints[file].Remove(line);
            if (_breakpoints[file].Count == 0) _breakpoints.Remove(file);
        }
        StateChanged?.Invoke(this, new DebuggerState { Breakpoints = new Dictionary<string, HashSet<int>>(_breakpoints) });
    }

    public void SetBreakpointEnabled(string file, int line, bool enabled)
    {
        if (enabled) _disabledBreakpoints.Remove($"{file}:{line}");
        else _disabledBreakpoints.Add($"{file}:{line}");
    }

    public void ClearAllBreakpoints()
    {
        _breakpoints.Clear();
        _disabledBreakpoints.Clear();
        StateChanged?.Invoke(this, new DebuggerState { Breakpoints = new Dictionary<string, HashSet<int>>() });
    }

    public void AddWatch(string expression)
    {
        if (!_watches.Contains(expression)) _watches.Add(expression);
    }

    public void RemoveWatch(string expression) => _watches.Remove(expression);

    public List<string> GetWatches() => new(_watches);

    public List<DebuggerFrame> GetCallStack()
    {
        // Stack iteration goes from top to bottom, so no need to reverse
        return _callStack.ToList();
    }

    public Dictionary<string, CraftValue> GetLocals()
    {
        return new Dictionary<string, CraftValue>(_locals);
    }

    private void OnLineNotify(string file, int line)
    {
        if (!_attached) return;
        _currentFile = file;
        _currentLine = line;

        var bpKey = $"{file}:{line}";
        if (_breakpoints.ContainsKey(file) && _breakpoints[file].Contains(line) && !_disabledBreakpoints.Contains(bpKey))
        {
            _paused = true;
            BreakpointHit?.Invoke(this, line);
            StateChanged?.Invoke(this, new DebuggerState { IsRunning = false, CurrentFile = file, CurrentLine = line });
            return;
        }

        if (_paused)
        {
            StateChanged?.Invoke(this, new DebuggerState { IsRunning = false, CurrentFile = file, CurrentLine = line });
        }
    }

    public void NotifyLine(string file, int line) => OnLineNotify(file, line);

    public void NotifyCall(string procName, string file, int line)
    {
        _callStack.Push(new DebuggerFrame { ProcName = procName, File = file, Line = line });
    }

    public void NotifyReturn()
    {
        if (_callStack.Count > 0) _callStack.Pop();
    }

    public void UpdateLocals(Dictionary<string, CraftValue> locals)
    {
        _locals = locals ?? new Dictionary<string, CraftValue>();
    }
}

public class DebuggerState
{
    public bool IsAttached { get; set; }
    public bool IsRunning { get; set; } = true;
    public StepMode StepMode { get; set; } = StepMode.None;
    public string CurrentFile { get; set; } = "";
    public int CurrentLine { get; set; }
    public Dictionary<string, HashSet<int>> Breakpoints { get; set; } = new();
    public List<string> Watches { get; set; } = new();
    public List<DebuggerFrame> CallStack { get; set; } = new();
    public Dictionary<string, CraftValue> Locals { get; set; } = new();
}

public enum StepMode
{
    None,
    StepOver,
    StepInto,
    StepOut
}

public class DebuggerFrame
{
    public string ProcName { get; set; } = "";
    public string File { get; set; } = "";
    public int Line { get; set; }
    public override string ToString() => $"{ProcName} ({System.IO.Path.GetFileName(File)}:{Line})";
}