// Commander X16 Emulator — Debug Adapter Protocol (DAP) Server

// Speaks DAP over TCP for direct IDE integration (Visual Studio, VS Code, etc.)

// Transport: Content-Length framed JSON over TCP, default port 9009

#include <SDL.h>

#include "debug_server.h"

#include "dbg_info.h"

#include "debugger.h"

#include "disasm.h"

#include "code_map.h"

#include "perf_budget.h"

#include "vera_bandwidth.h"

#include "perf_json.h"

#include "glue.h"

#include "memory.h"

#include "source_view.h"

#ifdef _WIN32

#include <ws2tcpip.h>

#else

#include <netinet/tcp.h>

#endif

#include "video.h"

#include "keyboard.h"

#include "joystick.h"

#include "cpu/fake6502.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <ctype.h>

#include <cjson/cJSON.h>

// Platform socket abstraction

#ifdef _WIN32

  #include <winsock2.h>

  #include <ws2tcpip.h>

  #pragma comment(lib, "ws2_32.lib")

  typedef SOCKET socket_t;

  #define SOCKET_INVALID INVALID_SOCKET

  #define CLOSE_SOCKET closesocket

  #define SOCK_ERRNO WSAGetLastError()

  #define WOULD_BLOCK (SOCK_ERRNO == WSAEWOULDBLOCK)

  static bool wsa_initialized = false;

#else

  #include <sys/socket.h>

  #include <netinet/in.h>

  #include <arpa/inet.h>

  #include <fcntl.h>

  #include <unistd.h>

  #include <errno.h>

  typedef int socket_t;

  #define SOCKET_INVALID (-1)

  #define CLOSE_SOCKET close

  #define SOCK_ERRNO errno

  #define WOULD_BLOCK (SOCK_ERRNO == EAGAIN || SOCK_ERRNO == EWOULDBLOCK)

#endif

// Receive buffer (large enough for DAP messages with headers)

#define RECV_BUF_SIZE 65536

static char recv_buf[RECV_BUF_SIZE];

static int  recv_buf_len = 0;

// Send buffer

#define SEND_BUF_SIZE 65536

static char send_buf[SEND_BUF_SIZE];

// Server state

static socket_t listen_sock = SOCKET_INVALID;

static socket_t client_sock = SOCKET_INVALID;

static bool     server_enabled = false;

static int      server_port = 0;

// DAP sequence counter (for events we send)

static int dap_seq = 1;

// DAP variable reference IDs

#define VARREF_REGISTERS  1

#define VARREF_ZEROPAGE   2

#define VARREF_STACK      3

#define VARREF_VREGS      4   // X16 16-bit virtual registers R0-R15 (ZP $02-$21)

// Breakpoint tracking for DAP (maps DAP bp IDs to addresses)

#define MAX_DAP_BREAKPOINTS 256

static struct {

    int  dap_id;       // DAP breakpoint ID

    uint16_t addr;     // resolved address

    char file[256];    // source file

    int  line;         // source line

    bool verified;

    uint8_t bank;      // program bank (65816); addresses are 24-bit

    int  x16Bank;      // the selector it was armed with; a removal that passes

                       // DEBUG_BANK_ANY will not match a bank-pinned entry

    // Kept so the breakpoint can be armed again exactly as the client asked for

    // it when an overlay reload forces it to be re-resolved. Without these, a

    // reload quietly turned a bank-pinned conditional breakpoint into an

    // unconditional one that fires in every bank.

    char cond[192];

    char hit_cond[64];

} dap_bps[MAX_DAP_BREAKPOINTS];

static int num_dap_bps = 0;

static int next_dap_bp_id = 1;

// Function/instruction breakpoints tracked separately so each re-set clears its

// own set. All three add into the same core table, which now records which of

// them asked -- so each can clear what it asked for without knowing or caring

// what anyone else wanted at the same address.

static uint16_t func_bp_addrs[128];

static uint8_t  func_bp_banks[128];

static int      num_func_bps = 0;

static uint16_t instr_bp_addrs[128];

static uint8_t  instr_bp_banks[128];

static int      num_instr_bps = 0;

static bool     dap_session_active = false;

// Whether the stop the machine is currently sitting in has been announced. A

// breakpoint can hit while the client is still configuring, and configurationDone

// would then report the same halt a second time under a different reason.

static bool     dap_stop_announced = false;

// Is there a local debugger UI whose user owns the run state?

//

// When there is, a client connecting or going away must not resume the machine:

// somebody is sitting at a breakpoint looking at it. When there is not -- a

// headless -debugport run -- nothing else can ever resume it, so a session

// ending has to.

//

// Both front ends count, and both need their own test. -imgui does not set

// debug_window_enabled, and -debugport sets debugger_enabled by itself, so

// neither flag alone answers the question: testing only the first ignored the

// graphical debugger entirely and resumed the machine out from under it.

static bool

dap_local_ui_owns_run_state(void)

{

	return (debug_window_enabled && debugger_enabled)

	       || (imgui_debugger_enabled && video_debug_ui_available());

}

// Forward declarations

static void send_dap_event(const char *event_name, cJSON *body);

static void send_dap_message(cJSON *json);

static int dap_apply_bp_condition(dbg_addr_t addr, const char *cond_str, const char *hit_str);

// Re-resolve unverified breakpoints after new .dbg file loads

static void retry_unverified_breakpoints(void) {

    for (int i = 0; i < num_dap_bps; i++) {

        if (!dap_bps[i].verified) {

            dbg_addr_t addr = 0;

            if (dbg_info_source_to_addr(dap_bps[i].file, dap_bps[i].line, &addr)) {

                // Re-arm it exactly as the client asked for it. Re-applying the

                // condition also recovers the bank pin, which decides the

                // selector the core entry is keyed on -- arming with ANY here

                // turned a bank-pinned conditional breakpoint into one that

                // fires in every bank on its first arrival.

                int bank_pin = dap_apply_bp_condition(addr,

                                                      dap_bps[i].cond,

                                                      dap_bps[i].hit_cond);

                dap_bps[i].addr = (uint16_t)(addr & 0xFFFF);

                dap_bps[i].bank = (uint8_t)(addr >> 16);

                dap_bps[i].verified = true;

                dap_bps[i].x16Bank = bank_pin;

                struct breakpoint hw_bp;

                hw_bp.pc = (int)(addr & 0xFFFF);

                hw_bp.bank = (uint8_t)(addr >> 16);

                hw_bp.x16Bank = bank_pin;

                debug_bp_add_for(hw_bp, DEBUG_OWNER_DAP_SOURCE);

                printf("[dap] Resolved pending breakpoint: %s:%d -> $%04X\n",

                       dap_bps[i].file, dap_bps[i].line, (unsigned)addr);

                // Say so. This is reached after invalidate_breakpoints_in_range()

                // has told the client the breakpoint is unverified, so staying

                // quiet would leave it showing one that is in fact armed.

                if (client_sock != SOCKET_INVALID) {

                    cJSON *body = cJSON_CreateObject();

                    cJSON *bp = cJSON_CreateObject();

                    cJSON_AddNumberToObject(bp, "id", dap_bps[i].dap_id);

                    cJSON_AddBoolToObject(bp, "verified", true);

                    cJSON_AddNumberToObject(bp, "line", dap_bps[i].line);

                    cJSON_AddItemToObject(body, "breakpoint", bp);

                    cJSON_AddStringToObject(body, "reason", "changed");

                    send_dap_event("breakpoint", body);

                }

            }

        }

    }

}

// Invalidate breakpoints whose addresses fall within a range being unloaded

static void invalidate_breakpoints_in_range(uint32_t start, uint32_t end) {

    // Compared as full 24-bit addresses, program bank included. Clamping the

    // range to 16 bits and comparing only the low half meant reloading a

    // bank-1 module left its breakpoints armed and stale, while reloading a

    // bank-0 range invalidated unrelated breakpoints in every other bank.

    for (int i = 0; i < num_dap_bps; i++) {

        const uint32_t bp_addr =

            ((uint32_t)dap_bps[i].bank << 16) | dap_bps[i].addr;

        if (dap_bps[i].verified && bp_addr >= start && bp_addr <= end) {

            // Drop this session's claim on the core entry. It goes only if

            // nothing else wants it, so a -bp or an F9 breakpoint at the same

            // address survives a module reload that has nothing to do with it.

            debug_bp_remove_for(dap_bps[i].addr, dap_bps[i].bank, dap_bps[i].x16Bank,

                                DEBUG_OWNER_DAP_SOURCE);

            dap_bps[i].addr = 0;

            dap_bps[i].bank = 0;

            printf("[dap] Invalidated breakpoint: %s:%d (range $%06X-$%06X unloaded)\n",

                   dap_bps[i].file, dap_bps[i].line, start, end);

            // Notify VS that breakpoint is no longer verified

            if (client_sock != SOCKET_INVALID) {

                cJSON *body = cJSON_CreateObject();

                cJSON *bp = cJSON_CreateObject();

                cJSON_AddNumberToObject(bp, "id", dap_bps[i].dap_id);

                cJSON_AddBoolToObject(bp, "verified", false);

                cJSON_AddStringToObject(bp, "message", "Module unloaded");

                cJSON_AddNumberToObject(bp, "line", dap_bps[i].line);

                cJSON_AddItemToObject(body, "breakpoint", bp);

                cJSON_AddStringToObject(body, "reason", "changed");

                send_dap_event("breakpoint", body);

            }

        }

    }

}

// Public wrappers so the shared runtime-load handler (debugger.c) can drive the

// DAP-only breakpoint bookkeeping around a module swap. Both are no-ops when no

// DAP client is connected, so the native source window works without DAP.

void debug_server_invalidate_breakpoints_in_range(uint32_t start, uint32_t end) {

    if (!server_enabled || client_sock == SOCKET_INVALID) return;

    invalidate_breakpoints_in_range(start, end);

}

void debug_server_retry_unverified_breakpoints(void) {

    if (!server_enabled || client_sock == SOCKET_INVALID) return;

    retry_unverified_breakpoints();

}

// ─── Platform helpers ───────────────────────────────────────────────

static bool set_nonblocking(socket_t sock) {

#ifdef _WIN32

    u_long mode = 1;

    return ioctlsocket(sock, FIONBIO, &mode) == 0;

#else

    int flags = fcntl(sock, F_GETFL, 0);

    if (flags < 0) return false;

    return fcntl(sock, F_SETFL, flags | O_NONBLOCK) == 0;

#endif

}

static bool platform_init(void) {

#ifdef _WIN32

    if (!wsa_initialized) {

        WSADATA wsa;

        if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {

            fprintf(stderr, "[dap] WSAStartup failed: %d\n", WSAGetLastError());

            return false;

        }

        wsa_initialized = true;

    }

#endif

    return true;

}

static void platform_cleanup(void) {

#ifdef _WIN32

    if (wsa_initialized) {

        WSACleanup();

        wsa_initialized = false;

    }

#endif

}

// ─── DAP message sending ────────────────────────────────────────────

static void disconnect_client(void);

static void dap_release_session_state(void);

static void send_dap_message(cJSON *json) {

    if (client_sock == SOCKET_INVALID) {

        cJSON_Delete(json);

        return;

    }

    char *body = cJSON_PrintUnformatted(json);

    if (body) {

        int body_len = (int)strlen(body);

        int header_len = snprintf(send_buf, sizeof(send_buf),

                                  "Content-Length: %d\r\n\r\n", body_len);

        if (header_len + body_len >= SEND_BUF_SIZE) {

            // Too large to frame. Dropping it silently left the client waiting

            // on a request_seq that would never be answered -- a source file

            // over 64K is enough to do it, and the editor shows a tab that

            // never finishes loading. The receive side already drops a client

            // it cannot buffer; do the same rather than hang.

            fprintf(stderr, "[dap] response of %d bytes exceeds the send buffer; dropping client\n",

                    header_len + body_len);

            cJSON_free(body);

            cJSON_Delete(json);

            disconnect_client();

            return;

        }

        {

            memcpy(send_buf + header_len, body, body_len);

            int total = header_len + body_len;

            int offset = 0;

            // A client that stops reading fills the socket buffer, and this is

            // the emulator's only thread. Retrying forever parks the machine on

            // a peer that may never come back, so give up after a bounded wait

            // and drop the client instead: a dead session is recoverable, a

            // frozen emulator is not.

            int stalls = 0;

            const int max_stalls = 500;          // ~500ms of a peer not reading

            while (offset < total) {

                int n = send(client_sock, send_buf + offset, total - offset, 0);

                if (n > 0) {

                    offset += n;

                    stalls = 0;

                } else if (n < 0 && WOULD_BLOCK) {

                    if (++stalls > max_stalls) {

                        fprintf(stderr, "[dap] client is not reading; dropping it\n");

                        disconnect_client();

                        break;

                    }

                    // SDL's, rather than Sleep/usleep behind a platform split:

                    // usleep needs a feature-test macro this file does not set,

                    // which only the -Werror Linux builds noticed.

                    SDL_Delay(1);

                } else {

                    break; // real error

                }

            }

        }

        cJSON_free(body);

    }

    cJSON_Delete(json);

}

static void send_dap_response(int request_seq, const char *command, bool success, cJSON *body) {

    cJSON *resp = cJSON_CreateObject();

    cJSON_AddNumberToObject(resp, "seq", dap_seq++);

    cJSON_AddStringToObject(resp, "type", "response");

    cJSON_AddNumberToObject(resp, "request_seq", request_seq);

    cJSON_AddBoolToObject(resp, "success", success);

    cJSON_AddStringToObject(resp, "command", command);

    if (body) {

        cJSON_AddItemToObject(resp, "body", body);

    }

    send_dap_message(resp);

}

static void send_dap_error_response(int request_seq, const char *command, const char *message) {

    cJSON *body = cJSON_CreateObject();

    cJSON *error_obj = cJSON_CreateObject();

    cJSON_AddNumberToObject(error_obj, "id", 1);

    cJSON_AddStringToObject(error_obj, "format", message);

    cJSON_AddItemToObject(body, "error", error_obj);

    cJSON *resp = cJSON_CreateObject();

    cJSON_AddNumberToObject(resp, "seq", dap_seq++);

    cJSON_AddStringToObject(resp, "type", "response");

    cJSON_AddNumberToObject(resp, "request_seq", request_seq);

    cJSON_AddBoolToObject(resp, "success", false);

    cJSON_AddStringToObject(resp, "command", command);

    cJSON_AddStringToObject(resp, "message", message);

    cJSON_AddItemToObject(resp, "body", body);

    send_dap_message(resp);

}

static void send_dap_event(const char *event_name, cJSON *body) {

    cJSON *event = cJSON_CreateObject();

    cJSON_AddNumberToObject(event, "seq", dap_seq++);

    cJSON_AddStringToObject(event, "type", "event");

    cJSON_AddStringToObject(event, "event", event_name);

    if (body) {

        cJSON_AddItemToObject(event, "body", body);

    }

    send_dap_message(event);

}

// ContinuedEvent — tell the client execution resumed (all threads).

static void send_continued_event(void) {

    dap_stop_announced = false;   // whatever we were stopped in is over

    if (client_sock == SOCKET_INVALID) return;

    cJSON *body = cJSON_CreateObject();

    cJSON_AddNumberToObject(body, "threadId", 1);

    cJSON_AddBoolToObject(body, "allThreadsContinued", true);

    send_dap_event("continued", body);

}

// OutputEvent — forward text to the client's debug console. Public API so the

// emulator can pipe program/console output to an attached DAP client.

void debug_server_output(const char *category, const char *text) {

    if (!server_enabled || client_sock == SOCKET_INVALID || !text) return;

    cJSON *body = cJSON_CreateObject();

    cJSON_AddStringToObject(body, "category", category ? category : "console");

    cJSON_AddStringToObject(body, "output", text);

    send_dap_event("output", body);

}

// Pending events to send on next poll (avoid back-to-back sends)

// Announces the single emulated CPU as a DAP thread. Sent after launch and

// after attach, which are the two ways a session starts.

static void send_dap_event_thread_started(void);

// Set by launch when the client asked to be given control before anything runs.

static bool dap_stop_on_entry = false;

// ─── DAP command handlers ───────────────────────────────────────────

static int handle_dap_initialize(int seq, cJSON *args) {

    (void)args;

    cJSON *caps = cJSON_CreateObject();

    cJSON_AddBoolToObject(caps, "supportsConfigurationDoneRequest", true);

    cJSON_AddBoolToObject(caps, "supportsSetVariable", true);

    cJSON_AddBoolToObject(caps, "supportsRestartRequest", true);

    cJSON_AddBoolToObject(caps, "supportsTerminateRequest", true);

    cJSON_AddBoolToObject(caps, "supportsReadMemoryRequest", true);

    cJSON_AddBoolToObject(caps, "supportsWriteMemoryRequest", true);

    cJSON_AddBoolToObject(caps, "supportsDisassembleRequest", true);

    cJSON_AddBoolToObject(caps, "supportTerminateDebuggee", true);

    cJSON_AddBoolToObject(caps, "supportsEvaluateForHovers", true);

    cJSON_AddBoolToObject(caps, "supportsSteppingGranularity", true);

    cJSON_AddBoolToObject(caps, "supportsGotoTargetsRequest", true);

    cJSON_AddBoolToObject(caps, "supportsSetExpression", false);

    cJSON_AddBoolToObject(caps, "supportsValueFormattingOptions", true);

    cJSON_AddBoolToObject(caps, "supportsFunctionBreakpoints", true);

    // Newly implemented in this build:

    cJSON_AddBoolToObject(caps, "supportsDataBreakpoints", true);

    cJSON_AddBoolToObject(caps, "supportsInstructionBreakpoints", true);

    cJSON_AddBoolToObject(caps, "supportsLoadedSourcesRequest", true);

    cJSON_AddBoolToObject(caps, "supportsBreakpointLocationsRequest", true);

    cJSON_AddBoolToObject(caps, "supportsStepInTargetsRequest", true);

    cJSON_AddBoolToObject(caps, "supportsConditionalBreakpoints", true);

    cJSON_AddBoolToObject(caps, "supportsHitConditionalBreakpoints", true);

    // Non-standard, so that a client can tell this emulator's performance

    // budget surface from one that would reject the requests.

    cJSON_AddBoolToObject(caps, "supportsX16PerfStats", true);

    send_dap_response(seq, "initialize", true, caps);

    dap_session_active = true;

    // Per the DAP spec this follows the initialize response immediately: a

    // client is entitled to wait for it before sending configurationDone, so

    // deferring it to the next request deadlocks anything strict about that.

    send_dap_event("initialized", NULL);

    return 0;

}

static int handle_dap_launch(int seq, cJSON *args) {

    // Load .dbg file if specified in launch arguments (additive, don't clear existing)

    if (args) {

        cJSON *dbg_file = cJSON_GetObjectItemCaseSensitive(args, "dbgFile");

        if (dbg_file && cJSON_IsString(dbg_file)) {

            if (dbg_info_load(dbg_file->valuestring) == 0) {

                printf("[dap] Loaded debug info: %s\n", dbg_file->valuestring);

            } else {

                fprintf(stderr, "[dap] Warning: failed to load debug info: %s\n",

                        dbg_file->valuestring);

            }

        }

        cJSON *soe = cJSON_GetObjectItemCaseSensitive(args, "stopOnEntry");

        dap_stop_on_entry = (soe && cJSON_IsTrue(soe));

    }

    send_dap_response(seq, "launch", true, NULL);

    send_dap_event_thread_started();

    return 0;

}

static int handle_dap_configuration_done(int seq) {

    send_dap_response(seq, "configurationDone", true, NULL);

    // Sending can drop the client -- a peer that stops reading is disconnected

    // rather than allowed to freeze the emulator -- so there may be no session

    // left to configure. Carrying on would halt a headless machine with nobody

    // able to resume it.

    if (client_sock == SOCKET_INVALID) {

        dap_stop_on_entry = false;

        return 0;

    }

    // Already halted, because a breakpoint set moments ago has hit or a

    // previous client left it that way. Report where we actually are; resuming

    // would drive past a stop the client should see, and saying nothing leaves

    // it showing a running target it cannot pause. Checked before stopOnEntry

    // so the same halt is not announced twice under two different reasons.

    if (currentMode == DMODE_STOP) {

        dap_stop_on_entry = false;

        // Unless it has already been reported -- a breakpoint that hit while

        // the client was still configuring emits its own stopped event, and

        // announcing the same halt again under a different reason confuses a

        // client into thinking it stopped twice.

        if (!dap_stop_announced) debug_server_notify_stopped("breakpoint");

        return 1;

    }

    // The client wants control before anything executes, and is waiting for the

    // stopped event to know it has it.

    if (dap_stop_on_entry) {

        dap_stop_on_entry = false;

        currentMode = DMODE_STOP;

        debug_server_notify_stopped("entry");

        return 1;

    }

    currentMode = DMODE_RUN;

    return 1;

}

static int handle_dap_threads(int seq) {

    cJSON *body = cJSON_CreateObject();

    cJSON *threads = cJSON_CreateArray();

    cJSON *thread = cJSON_CreateObject();

    cJSON_AddNumberToObject(thread, "id", 1);

    cJSON_AddStringToObject(thread, "name", "6502 CPU");

    cJSON_AddItemToArray(threads, thread);

    cJSON_AddItemToObject(body, "threads", threads);

    send_dap_response(seq, "threads", true, body);

    return 0;

}

// Build a DAP stack frame object for a code address. `bank` is the 65C816

// program bank (0 on the 65C02); it makes the instructionPointerReference a

// full 24-bit address so disassembly opens in the right bank on GS.

static cJSON *build_stack_frame(int id, uint16_t addr, uint8_t bank, bool is_current) {

    cJSON *frame = cJSON_CreateObject();

    cJSON_AddNumberToObject(frame, "id", id);

    const char *src_file = NULL;

    int         src_line = 0;

    bool        has_source = dbg_info_addr_to_source_banked(addr, (int)memory_get_ram_bank(),

                                                            &src_file, &src_line);

    const char *label = NULL;

    char        name_buf[80];

    const char *afmt = (bank != 0 || is_gen2) ? "%s ($%02X:%04X)" : "%s ($%04X)";

    const char *nfmt = (bank != 0 || is_gen2) ? "$%02X:%04X" : "$%04X";

    if (dbg_info_addr_to_label(addr, &label) && label) {

        if (bank != 0 || is_gen2) snprintf(name_buf, sizeof(name_buf), afmt, label, bank, addr);

        else                      snprintf(name_buf, sizeof(name_buf), afmt, label, addr);

    } else {

        if (bank != 0 || is_gen2) snprintf(name_buf, sizeof(name_buf), nfmt, bank, addr);

        else                      snprintf(name_buf, sizeof(name_buf), nfmt, addr);

    }

    cJSON_AddStringToObject(frame, "name", name_buf);

    cJSON_AddNumberToObject(frame, "line", has_source ? src_line : 0);

    cJSON_AddNumberToObject(frame, "column", 1);

    if (has_source) {

        cJSON *source = cJSON_CreateObject();