using System;

using System.Collections.Generic;

using System.IO;

using System.Net.Sockets;

using System.Text;

using System.Text.Json;

using System.Text.Json.Nodes;

using System.Threading;

using System.Threading.Tasks;

namespace X16Debug;

/// <summary>

/// TCP client for the x16emu DAP (Debug Adapter Protocol) debug server.

/// Uses Content-Length framing: "Content-Length: N\r\n\r\n{json}"

/// </summary>

public class X16DebugClient : IDisposable

{

    private TcpClient? _tcp;

    private Stream? _stream;

    private int _nextSeq = 1;

    private readonly object _lock = new();

    private readonly Dictionary<int, TaskCompletionSource<JsonNode>> _pending = new();

    private readonly List<TaskCompletionSource<JsonNode>> _eventWaiters = new();

    private CancellationTokenSource? _cts;

    private Task? _listenerTask;

    public event Action<JsonNode>? OnEvent;

    public bool IsConnected => _tcp?.Connected == true;

    public async Task ConnectAsync(string host, int port, int timeoutMs = 5000)

    {

        _tcp = new TcpClient();

        using var cts = new CancellationTokenSource(timeoutMs);

        await _tcp.ConnectAsync(host, port, cts.Token);

        _stream = _tcp.GetStream();

        _cts = new CancellationTokenSource();

        _listenerTask = Task.Run(() => ListenerLoop(_cts.Token));

    }

    /// <summary>

    /// Perform the DAP initialization handshake: initialize -> wait for initialized event -> configurationDone.

    /// Must be called after ConnectAsync before any other commands.

    /// </summary>

    public async Task<JsonNode> InitializeAsync()

    {

        var initArgs = new JsonObject

        {

            ["clientID"] = "x16dbg",

            ["clientName"] = "X16 Debug Client",

            ["adapterID"] = "x16emu",

            ["supportsVariableType"] = true,

            ["supportsReadMemoryRequest"] = true,

        };

        var initResponse = await SendRequestAsync("initialize", initArgs);

        // Wait for the "initialized" event from the server

        await WaitForEventAsync("initialized", 5000);

        // Complete configuration

        await SendRequestAsync("configurationDone");

        return initResponse;

    }

    // ─── Core DAP transport ─────────────────────────────────────────

    /// <summary>

    /// Send a DAP request and wait for its matching response.

    /// </summary>

    public async Task<JsonNode> SendRequestAsync(string command, JsonNode? arguments = null, int timeoutMs = 10000)

    {

        int seq;

        var tcs = new TaskCompletionSource<JsonNode>();

        lock (_lock)

        {

            seq = _nextSeq++;

            _pending[seq] = tcs;

        }

        var msg = new JsonObject

        {

            ["seq"] = seq,

            ["type"] = "request",

            ["command"] = command,

        };

        if (arguments != null)

            msg["arguments"] = arguments;

        await SendDapMessageAsync(msg);

        using var cts = new CancellationTokenSource(timeoutMs);

        cts.Token.Register(() => tcs.TrySetCanceled());

        return await tcs.Task;

    }

    /// <summary>

    /// Wait for a specific DAP event by name.

    /// </summary>

    public Task<JsonNode> WaitForEventAsync(string eventName, int timeoutMs = 10000)

    {

        var tcs = new TaskCompletionSource<JsonNode>();

        Action<JsonNode>? handler = null;

        handler = (evt) =>

        {

            if (evt["event"]?.GetValue<string>() == eventName)

            {

                OnEvent -= handler;

                tcs.TrySetResult(evt);

            }

        };

        OnEvent += handler;

        var cts = new CancellationTokenSource(timeoutMs);

        cts.Token.Register(() =>

        {

            OnEvent -= handler;

            tcs.TrySetCanceled();

        });

        return tcs.Task;

    }

    private async Task SendDapMessageAsync(JsonObject msg)

    {

        string json = msg.ToJsonString();

        byte[] body = Encoding.UTF8.GetBytes(json);

        string header = $"Content-Length: {body.Length}\r\n\r\n";

        byte[] headerBytes = Encoding.ASCII.GetBytes(header);

        byte[] packet = new byte[headerBytes.Length + body.Length];

        Buffer.BlockCopy(headerBytes, 0, packet, 0, headerBytes.Length);

        Buffer.BlockCopy(body, 0, packet, headerBytes.Length, body.Length);

        await _stream!.WriteAsync(packet);

        await _stream.FlushAsync();

    }

    private async Task ListenerLoop(CancellationToken ct)

    {

        try

        {

            while (!ct.IsCancellationRequested && _stream != null)

            {

                var node = await ReadDapMessageAsync(ct);

                if (node == null) break;

                string? type = node["type"]?.GetValue<string>();

                if (type == "response")

                {

                    int reqSeq = node["request_seq"]!.GetValue<int>();

                    lock (_lock)

                    {

                        if (_pending.TryGetValue(reqSeq, out var tcs))

                        {

                            _pending.Remove(reqSeq);

                            tcs.SetResult(node);

                        }

                    }

                }

                else if (type == "event")

                {

                    OnEvent?.Invoke(node);

                }

            }

        }

        catch (OperationCanceledException) { }

        catch (IOException) { }

        catch (Exception ex)

        {

            Console.Error.WriteLine($"[listener] Error: {ex.Message}");

        }

    }

    /// <summary>

    /// Read one DAP message: parse Content-Length header, then read that many bytes of JSON.

    /// </summary>

    private async Task<JsonNode?> ReadDapMessageAsync(CancellationToken ct)

    {

        // Read headers line by line until we hit the empty line (\r\n\r\n)

        int contentLength = -1;

        while (true)

        {

            string? headerLine = await ReadLineAsync(ct);

            if (headerLine == null) return null; // connection closed

            if (headerLine.Length == 0)

                break; // end of headers

            if (headerLine.StartsWith("Content-Length:", StringComparison.OrdinalIgnoreCase))

            {

                string val = headerLine.Substring("Content-Length:".Length).Trim();

                contentLength = int.Parse(val);

            }

        }

        if (contentLength < 0)

            return null;

        // Read exactly contentLength bytes

        byte[] buffer = new byte[contentLength];

        int totalRead = 0;

        while (totalRead < contentLength)

        {

            int read = await _stream!.ReadAsync(buffer, totalRead, contentLength - totalRead, ct);

            if (read == 0) return null; // connection closed

            totalRead += read;

        }

        string json = Encoding.UTF8.GetString(buffer);

        return JsonNode.Parse(json);

    }

    /// <summary>

    /// Read a single \r\n-terminated line from the raw stream (for DAP headers).

    /// </summary>

    private async Task<string?> ReadLineAsync(CancellationToken ct)

    {

        var sb = new StringBuilder();

        byte[] buf = new byte[1];

        bool prevCR = false;

        while (true)

        {

            int read = await _stream!.ReadAsync(buf, 0, 1, ct);

            if (read == 0) return null;

            char c = (char)buf[0];

            if (c == '\n' && prevCR)

            {

                // Remove the trailing CR we appended

                if (sb.Length > 0 && sb[sb.Length - 1] == '\r')

                    sb.Length--;

                return sb.ToString();

            }

            prevCR = c == '\r';

            sb.Append(c);

        }

    }

    // ─── Execution commands ─────────────────────────────────────────

    public Task<JsonNode> StepInAsync() =>

        SendRequestAsync("stepIn", new JsonObject { ["threadId"] = 1 });

    public Task<JsonNode> StepOverAsync() =>

        SendRequestAsync("next", new JsonObject { ["threadId"] = 1 });

    public Task<JsonNode> StepOutAsync() =>

        SendRequestAsync("stepOut", new JsonObject { ["threadId"] = 1 });

    public Task<JsonNode> ContinueAsync() =>

        SendRequestAsync("continue", new JsonObject { ["threadId"] = 1 });

    public Task<JsonNode> PauseAsync() =>

        SendRequestAsync("pause", new JsonObject { ["threadId"] = 1 });

    public Task<JsonNode> DisconnectAsync(bool terminateDebuggee = false) =>

        SendRequestAsync("disconnect", new JsonObject { ["terminateDebuggee"] = terminateDebuggee });

    // ─── State inspection ───────────────────────────────────────────

    public Task<JsonNode> GetThreadsAsync() =>

        SendRequestAsync("threads");

    public Task<JsonNode> GetStackTraceAsync(int threadId = 1) =>

        SendRequestAsync("stackTrace", new JsonObject { ["threadId"] = threadId });

    public Task<JsonNode> GetScopesAsync(int frameId) =>

        SendRequestAsync("scopes", new JsonObject { ["frameId"] = frameId });

    public Task<JsonNode> GetVariablesAsync(int variablesReference) =>

        SendRequestAsync("variables", new JsonObject { ["variablesReference"] = variablesReference });

    /// <summary>

    /// Helper: stackTrace -> scopes -> variables to get the "Registers" scope.

    /// The emulator uses variablesReference=1 for Registers.

    /// </summary>

    public async Task<JsonNode> GetRegistersAsync()

    {

        var stack = await GetStackTraceAsync(1);

        var frames = stack["body"]?["stackFrames"]?.AsArray();

        if (frames == null || frames.Count == 0)

            throw new InvalidOperationException("No stack frames available");

        int frameId = frames[0]!["id"]!.GetValue<int>();

        var scopes = await GetScopesAsync(frameId);

        var scopeArray = scopes["body"]?["scopes"]?.AsArray();

        if (scopeArray == null)

            throw new InvalidOperationException("No scopes available");

        // Find the "Registers" scope (variablesReference=1 by convention)

        int registersRef = -1;

        foreach (var scope in scopeArray)

        {

            string? name = scope?["name"]?.GetValue<string>();

            if (name != null && name.Equals("Registers", StringComparison.OrdinalIgnoreCase))

            {

                registersRef = scope!["variablesReference"]!.GetValue<int>();

                break;

            }

        }

        // Fallback: use variablesReference=1 directly

        if (registersRef < 0)

            registersRef = 1;

        return await GetVariablesAsync(registersRef);

    }

    public Task<JsonNode> ReadMemoryAsync(int address, int count) =>

        ReadMemoryAsync($"${address:X4}", count);

    /// <summary>

    /// Read memory by raw DAP reference. A bare address is CPU space; a "vram:"

    /// prefix reaches VERA's 17-bit video RAM, which is not in the CPU map at all.

    /// </summary>

    public Task<JsonNode> ReadMemoryAsync(string memoryReference, int count) =>

        SendRequestAsync("readMemory", new JsonObject

        {

            ["memoryReference"] = memoryReference,

            ["count"] = count

        });

    /// <summary>

    /// Write memory by raw DAP reference, same address rules as ReadMemoryAsync.

    /// This is the only way to write VRAM: the CPU reaches it through VERA's data

    /// port one auto-incrementing byte at a time, so there is no CPU address for it.

    /// </summary>

    public Task<JsonNode> WriteMemoryAsync(string memoryReference, byte[] data) =>

        SendRequestAsync("writeMemory", new JsonObject

        {

            ["memoryReference"] = memoryReference,

            ["data"] = Convert.ToBase64String(data)

        });

    // ─── Virtual joysticks ──────────────────────────────────────────

    /// <summary>

    /// Drive one of the four SNES controller ports. Needs no gamepad attached and

    /// no -joy1..-joy4 flag.

    ///

    /// buttons is the complete held set, so anything left out of it is released;

    /// passing null for every argument but index queries the port without

    /// changing it. Set enabled=false to hand the port back to a physical pad.

    /// </summary>

    public Task<JsonNode> JoystickAsync(int index, IEnumerable<string>? buttons = null,

                                        int? mask = null, bool? enabled = null)

    {

        var args = new JsonObject { ["index"] = index };

        if (buttons != null)

        {

            var arr = new JsonArray();

            foreach (var b in buttons) arr.Add(b);

            args["buttons"] = arr;

        }

        if (mask.HasValue) args["mask"] = mask.Value;

        if (enabled.HasValue) args["enabled"] = enabled.Value;

        return SendRequestAsync("x16/joystick", args);

    }

    public Task<JsonNode> EvaluateAsync(string expression) =>

        SendRequestAsync("evaluate", new JsonObject

        {

            ["expression"] = expression,

            ["frameId"] = 0

        });

    /// <summary>

    /// Set a variable in a scope. The emulator uses variablesReference=1 for the

    /// Registers scope. This is the request that actually writes a register --

    /// the evaluate expression "A=FF" is parsed as a read and silently does

    /// nothing.

    /// </summary>

    public Task<JsonNode> SetVariableAsync(string name, string value, int variablesReference = 1) =>

        SendRequestAsync("setVariable", new JsonObject

        {

            ["variablesReference"] = variablesReference,

            ["name"] = name,

            ["value"] = value

        });

    // ─── Breakpoints (via evaluate) ─────────────────────────────────

    public Task<JsonNode> AddBreakpointAsync(int address) =>

        EvaluateAsync($"bp_add {address:X4}");

    public Task<JsonNode> RemoveBreakpointAsync(int address) =>

        EvaluateAsync($"bp_remove {address:X4}");

    public Task<JsonNode> ListBreakpointsAsync() =>

        EvaluateAsync("bp_list");

    public Task<JsonNode> ClearBreakpointsAsync() =>

        EvaluateAsync("bp_clear");

    public void Dispose()

    {

        _cts?.Cancel();

        _stream?.Dispose();

        _tcp?.Dispose();

        _listenerTask?.Wait(1000);

    }

}