/* retro_control.c — portable emulator control server. See retro_control.h

 * and ../SPEC.md. POSIX (Linux/macOS); on Windows the entry points are no-ops.

 *

 * One accept thread, one request in flight at a time. State reads are marshalled

 * to the emulator thread via retro_control_service() so they observe a

 * consistent machine; /step is driven cooperatively by retro_control_on_frame().

 */

#include "retro_control.h"

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#if defined(_WIN32) || defined(__EMSCRIPTEN__)

/* No TCP control server on Windows or in the browser (emscripten) — a localhost

 * socket server has no meaning there. Stub out so those builds still link. */

int  retro_control_start(int port, const retro_control_backend_t *b) { (void)port; (void)b; return -1; }

void retro_control_service(void) {}

int  retro_control_running(void) { return 1; }

void retro_control_on_frame(void) {}

void retro_control_stop(void) {}

#else

#include <pthread.h>

#include <stdatomic.h>

#include <unistd.h>

#include <errno.h>

#include <limits.h>

#include <signal.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#ifndef MSG_NOSIGNAL

#define MSG_NOSIGNAL 0

#endif

#define MEM_CAP (1u << 20)   /* /mem hard cap: 1 MiB per request */

static const retro_control_backend_t *g_be = NULL;

static int       g_listen_fd = -1;

static pthread_t g_thread;

static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER;

static pthread_cond_t  g_cv   = PTHREAD_COND_INITIALIZER;

/* run control: -1 free-run, 0 halted, >0 run this many frames then halt.

 * Atomic so retro_control_running() (called every instruction) reads it without

 * taking the lock — the mutex is kept only for the /step completion handshake. */

static _Atomic long g_frames_to_run = -1;

static int  g_step_waiting  = 0;

/* single-slot marshalled request. */

typedef enum { REQ_NONE = 0, REQ_MEM, REQ_REGS, REQ_SHOT, REQ_KEY, REQ_RESET,

               REQ_WRITE, REQ_AUDIO, REQ_PTR_SET, REQ_PTR_GET,

               REQ_PAD_SET, REQ_PAD_GET, REQ_PERF_GET, REQ_PERF_SET } req_t;

static volatile req_t g_req = REQ_NONE;

static uint32_t g_req_addr, g_req_len;

static int32_t  g_req_bank;

static const uint8_t *g_write_data;   /* POST /mem body (HTTP-thread owned) */

static int      g_key_is_text;   /* 1 => g_key_value is a char code point */

static uint32_t g_key_value;

static int      g_key_action;    /* retro_key_action_t */

static int      g_ptr_absolute;  /* 1 => (x,y) absolute; 0 => relative deltas */

static int32_t  g_ptr_x, g_ptr_y;

static int      g_ptr_buttons;   /* button bitmask, or -1 = leave unchanged */

static int      g_pad_index;     /* which pad (0-based) */

static int      g_pad_buttons;   /* held mask, or -1 = leave unchanged */

static int      g_pad_connected; /* 1 plug, 0 unplug, -1 = unchanged */

static char     g_resp_extra[64];     /* extra response header line, or "" */

static char     g_perf_query[1024];   /* GET /perf's query string (0.6) */

static const char *g_perf_body;       /* POST /perf's body, NUL-terminated (HTTP-thread owned) */

static uint8_t    *g_resp_body  = NULL;

static size_t      g_resp_len   = 0;

static int         g_resp_status = 200;

static const char *g_resp_ctype = "application/octet-stream";

static int         g_resp_ready = 0;

/* ---- emulator-thread side ------------------------------------------------ */

static void build_ppm(void)

{

    retro_framebuffer_t fb;

    memset(&fb, 0, sizeof fb);

    g_be->get_framebuffer(&fb);

    int w = fb.width, h = fb.height;

    int bpp = (fb.fmt == RETRO_PIX_RGB888) ? 3 : 4;

    char hdr[64];

    int hl = snprintf(hdr, sizeof hdr, "P6\n%d %d\n255\n", w, h);

    size_t total = (size_t)hl + (size_t)3 * w * h;

    uint8_t *out = (uint8_t *)malloc(total ? total : 1);

    if (!out) { g_resp_body = NULL; g_resp_len = 0; g_resp_status = 500; return; }

    memcpy(out, hdr, hl);

    uint8_t *p = out + hl;

    const uint8_t *s = fb.pixels;

    for (int i = 0; i < w * h; i++) {

        const uint8_t *px = s + (size_t)i * bpp;

        if (fb.fmt == RETRO_PIX_BGRA8888) {

            p[0] = px[2]; p[1] = px[1]; p[2] = px[0];

        } else {                       /* RGB888 / RGBA8888 */

            p[0] = px[0]; p[1] = px[1]; p[2] = px[2];

        }

        p += 3;

    }

    g_resp_body = out;

    g_resp_len = total;

    g_resp_status = 200;

    g_resp_ctype = "image/x-portable-pixmap";

}

#define AUDIO_MAX_SAMPLES (1u << 18)   /* drain cap: 256K int16 (~2.7 s stereo @48.8k) */

static void le16(uint8_t *p, uint16_t v) { p[0] = v; p[1] = v >> 8; }

static void le32(uint8_t *p, uint32_t v) { p[0] = v; p[1] = v >> 8; p[2] = v >> 16; p[3] = v >> 24; }

/* Drain the backend's audio ring and wrap it as a canonical PCM WAV. */

static void build_wav(void)

{

    static int16_t samp[AUDIO_MAX_SAMPLES];

    int rate = 48000, channels = 1;

    uint32_t dropped = 0;

    uint32_t n = g_be->capture_audio(samp, AUDIO_MAX_SAMPLES, &rate, &channels, &dropped);

    if (channels < 1) channels = 1;

    if (rate < 1) rate = 1;

    uint32_t data_bytes = n * 2;               /* int16 samples */

    uint32_t total = 44 + data_bytes;

    uint8_t *out = (uint8_t *)malloc(total);

    if (!out) { g_resp_body = NULL; g_resp_len = 0; g_resp_status = 500; return; }

    uint32_t byte_rate = (uint32_t)rate * channels * 2;

    memcpy(out, "RIFF", 4);       le32(out + 4, 36 + data_bytes);

    memcpy(out + 8, "WAVE", 4);

    memcpy(out + 12, "fmt ", 4);  le32(out + 16, 16);

    le16(out + 20, 1);            le16(out + 22, (uint16_t)channels);

    le32(out + 24, (uint32_t)rate);

    le32(out + 28, byte_rate);    le16(out + 32, (uint16_t)(channels * 2));

    le16(out + 34, 16);

    memcpy(out + 36, "data", 4);  le32(out + 40, data_bytes);

    memcpy(out + 44, samp, data_bytes);

    g_resp_body = out; g_resp_len = total; g_resp_status = 200;

    g_resp_ctype = "audio/wav";

    snprintf(g_resp_extra, sizeof g_resp_extra,

             "X-Rrdc-Audio-Dropped: %u\r\n", (unsigned)dropped);

}

void retro_control_service(void)

{

    if (!g_be || g_req == REQ_NONE) return;   /* cheap unlocked fast-path */

    pthread_mutex_lock(&g_lock);

    g_resp_extra[0] = 0;

    switch (g_req) {

    case REQ_MEM: {

        uint32_t len = g_req_len > MEM_CAP ? MEM_CAP : g_req_len;

        uint8_t *buf = (uint8_t *)malloc(len ? len : 1);

        uint32_t got = 0;

        if (buf && g_be->read_mem) got = g_be->read_mem(g_req_addr, g_req_bank, len, buf, len);

        g_resp_body = buf; g_resp_len = got;

        g_resp_status = g_be->read_mem ? 200 : 501;

        g_resp_ctype = "application/octet-stream";

        break;

    }

    case REQ_REGS: {

        char *buf = (char *)malloc(1024);

        if (buf && g_be->get_regs_json) { g_be->get_regs_json(buf, 1024); }

        else if (buf) { buf[0] = 0; }

        g_resp_body = (uint8_t *)buf; g_resp_len = buf ? strlen(buf) : 0;

        g_resp_status = g_be->get_regs_json ? 200 : 501;

        g_resp_ctype = "application/json";

        break;

    }

    case REQ_SHOT:

        if (g_be->get_framebuffer) build_ppm();

        else { g_resp_body = NULL; g_resp_len = 0; g_resp_status = 501; }

        break;

    case REQ_KEY: {

        const char *json;

        if (!g_be->inject_key) {

            json = "{\"error\":\"not implemented\"}"; g_resp_status = 501;

        } else if (g_be->inject_key(g_key_is_text, g_key_value, g_key_action)) {

            json = "{\"injected\":true}"; g_resp_status = 200;

        } else {

            json = "{\"error\":\"unmapped key\"}"; g_resp_status = 400;

        }

        size_t l = strlen(json);

        uint8_t *b = (uint8_t *)malloc(l + 1);

        if (b) memcpy(b, json, l + 1);

        g_resp_body = b; g_resp_len = b ? l : 0;

        g_resp_ctype = "application/json";

        break;

    }

    case REQ_RESET: {

        const char *json;

        if (g_be->reset) { g_be->reset(); json = "{\"reset\":true}"; g_resp_status = 200; }

        else { json = "{\"error\":\"not implemented\"}"; g_resp_status = 501; }

        size_t l = strlen(json);

        uint8_t *b = (uint8_t *)malloc(l + 1);

        if (b) memcpy(b, json, l + 1);

        g_resp_body = b; g_resp_len = b ? l : 0;

        g_resp_ctype = "application/json";

        break;

    }

    case REQ_WRITE: {

        const char *json; char *b;

        if (!g_be->write_mem) {

            json = "{\"error\":\"not implemented\"}"; g_resp_status = 501;

            size_t l = strlen(json); b = (char *)malloc(l + 1);

            if (b) memcpy(b, json, l + 1);

            g_resp_len = b ? l : 0;

        } else {

            uint32_t wrote = g_be->write_mem(g_req_addr, g_req_bank, g_req_len, g_write_data);

            b = (char *)malloc(48);

            g_resp_len = b ? (size_t)snprintf(b, 48, "{\"written\":%u}", (unsigned)wrote) : 0;

            g_resp_status = 200;

        }

        g_resp_body = (uint8_t *)b;

        g_resp_ctype = "application/json";

        break;

    }

    case REQ_AUDIO:

        if (g_be->capture_audio) build_wav();

        else {

            const char *json = "{\"error\":\"not implemented\"}";

            size_t l = strlen(json); uint8_t *b = (uint8_t *)malloc(l + 1);

            if (b) memcpy(b, json, l + 1);

            g_resp_body = b; g_resp_len = b ? l : 0; g_resp_status = 501;

            g_resp_ctype = "application/json";

        }

        break;

    case REQ_PTR_SET: {

        const char *json;

        if (!g_be->set_pointer) {

            json = "{\"error\":\"not implemented\"}"; g_resp_status = 501;

        } else if (g_be->set_pointer(g_ptr_absolute, g_ptr_x, g_ptr_y, g_ptr_buttons)) {

            json = "{\"injected\":true}"; g_resp_status = 200;

        } else {

            json = "{\"error\":\"no pointer\"}"; g_resp_status = 400;

        }

        size_t l = strlen(json);

        uint8_t *b = (uint8_t *)malloc(l + 1);

        if (b) memcpy(b, json, l + 1);

        g_resp_body = b; g_resp_len = b ? l : 0;

        g_resp_ctype = "application/json";

        break;

    }

    case REQ_PTR_GET: {

        char *b;

        if (!g_be->get_pointer) {

            const char *json = "{\"error\":\"not implemented\"}";

            size_t l = strlen(json); b = (char *)malloc(l + 1);

            if (b) memcpy(b, json, l + 1);

            g_resp_len = b ? l : 0; g_resp_status = 501;

        } else {

            int32_t x = 0, y = 0; int buttons = 0;

            int ok = g_be->get_pointer(&x, &y, &buttons);

            b = (char *)malloc(96);

            if (!b) { g_resp_len = 0; g_resp_status = 500; }

            else if (ok) {

                g_resp_len = (size_t)snprintf(b, 96,

                    "{\"x\":%ld,\"y\":%ld,\"buttons\":%d}",

                    (long)x, (long)y, buttons);

                g_resp_status = 200;

            } else {

                g_resp_len = (size_t)snprintf(b, 96, "{\"error\":\"no pointer\"}");

                g_resp_status = 400;

            }

        }

        g_resp_body = (uint8_t *)b;

        g_resp_ctype = "application/json";

        break;

    }

    case REQ_PAD_SET: {

        const char *json;

        if (!g_be->set_pad) {

            json = "{\"error\":\"not implemented\"}"; g_resp_status = 501;

        } else if (g_be->set_pad(g_pad_index, g_pad_buttons, g_pad_connected)) {

            json = "{\"injected\":true}"; g_resp_status = 200;

        } else {

            json = "{\"error\":\"no controller\"}"; g_resp_status = 400;

        }

        size_t l = strlen(json);

        uint8_t *b = (uint8_t *)malloc(l + 1);

        if (b) memcpy(b, json, l + 1);

        g_resp_body = b; g_resp_len = b ? l : 0;

        g_resp_ctype = "application/json";

        break;

    }

    case REQ_PAD_GET: {

        char *b;

        if (!g_be->get_pad) {

            const char *json = "{\"error\":\"not implemented\"}";

            size_t l = strlen(json); b = (char *)malloc(l + 1);

            if (b) memcpy(b, json, l + 1);

            g_resp_len = b ? l : 0; g_resp_status = 501;

        } else {

            int buttons = 0, connected = 0;

            int ok = g_be->get_pad(g_pad_index, &buttons, &connected);

            b = (char *)malloc(96);

            if (!b) { g_resp_len = 0; g_resp_status = 500; }

            else if (ok) {

                g_resp_len = (size_t)snprintf(b, 96,

                    "{\"index\":%d,\"connected\":%s,\"buttons\":%d}",

                    g_pad_index, connected ? "true" : "false", buttons);

                g_resp_status = 200;

            } else {

                g_resp_len = (size_t)snprintf(b, 96,

                    "{\"error\":\"no controller\"}");

                g_resp_status = 400;

            }

        }

        g_resp_body = (uint8_t *)b;

        g_resp_ctype = "application/json";

        break;

    }

    case REQ_PERF_GET:

    case REQ_PERF_SET: {

        char *b = NULL;

        int st = 200;

        int have = (g_req == REQ_PERF_GET) ? g_be->get_perf != NULL : g_be->set_perf != NULL;

        if (!have) {

            st = 501;

        } else if (g_req == REQ_PERF_GET) {

            b = g_be->get_perf(g_perf_query);

        } else {

            b = g_be->set_perf(g_perf_body ? g_perf_body : "", &st);

            if (st != 200 && st != 400) st = 400;

        }

        if (!b) {                             /* not implemented, or the backend failed */

            const char *json = (st == 501) ? "{\"error\":\"not implemented\"}"

                                           : "{\"error\":\"perf failed\"}";

            if (st != 501) st = 500;

            size_t l = strlen(json);

            b = (char *)malloc(l + 1);

            if (b) memcpy(b, json, l + 1);

        }

        g_resp_body = (uint8_t *)b; g_resp_len = b ? strlen(b) : 0;

        g_resp_status = st;

        g_resp_ctype = "application/json";

        break;

    }

    default: break;

    }

    g_req = REQ_NONE;

    g_resp_ready = 1;

    pthread_cond_broadcast(&g_cv);

    pthread_mutex_unlock(&g_lock);

}

int retro_control_running(void)

{

    if (!g_be) return 1;

    /* Lock-free hot path: a word-sized atomic read, no mutex. The gate

     * tolerates a one-iteration-stale value; /step correctness is enforced by

     * the mutex + condvar in on_frame/do_step, not by this read. */

    return atomic_load_explicit(&g_frames_to_run, memory_order_relaxed) != 0;

}

void retro_control_on_frame(void)

{

    if (!g_be) return;

    pthread_mutex_lock(&g_lock);

    if (g_frames_to_run > 0) {

        g_frames_to_run--;

        if (g_frames_to_run == 0 && g_step_waiting) {

            g_step_waiting = 0;

            g_resp_ready = 1;

            pthread_cond_broadcast(&g_cv);

        }

    }

    pthread_mutex_unlock(&g_lock);

}

/* ---- server-thread side -------------------------------------------------- */

static void write_all(int fd, const void *buf, size_t len)

{

    const char *p = (const char *)buf;

    while (len) {

        ssize_t w = send(fd, p, len, MSG_NOSIGNAL);

        if (w <= 0) return;

        p += w; len -= (size_t)w;

    }

}

/* `extra`, if non-NULL, is a complete header line ("Name: value\r\n"). */

static void send_http(int fd, int status, const char *ctype,

                      const uint8_t *body, size_t len, const char *extra)

{

    const char *reason =

        status == 200 ? "OK" :

        status == 400 ? "Bad Request" :

        status == 404 ? "Not Found" :

        status == 405 ? "Method Not Allowed" :

        status == 500 ? "Internal Server Error" :

        status == 501 ? "Not Implemented" : "Error";

    char hdr[320];

    int hl = snprintf(hdr, sizeof hdr,

        "HTTP/1.1 %d %s\r\nContent-Type: %s\r\nContent-Length: %zu\r\n"

        "Connection: close\r\nAccess-Control-Allow-Origin: *\r\n%s\r\n",

        status, reason, ctype, len, extra ? extra : "");

    write_all(fd, hdr, hl);

    if (body && len) write_all(fd, body, len);

}

static void send_json(int fd, int status, const char *json)

{

    send_http(fd, status, "application/json", (const uint8_t *)json, strlen(json), NULL);

}

/* value of query key, decimal or 0x-hex (strtol base 0); def if absent. */

static long query_long(const char *q, const char *key, long def)

{

    size_t kl = strlen(key);

    const char *p = q;

    while (p && *p) {

        if (!strncmp(p, key, kl) && p[kl] == '=')

            return strtol(p + kl + 1, NULL, 0);

        p = strchr(p, '&');

        if (p) p++;

    }

    return def;

}

/* one hex nibble, or -1. */

static int hex_nibble(int c)

{

    if (c >= '0' && c <= '9') return c - '0';

    if (c >= 'a' && c <= 'f') return c - 'a' + 10;

    if (c >= 'A' && c <= 'F') return c - 'A' + 10;

    return -1;

}

/* copy the value of query key into out (NUL-terminated, truncated to cap),

 * percent-decoding it (form-urlencoded: %XX -> byte, '+' -> space). Numeric

 * params are read with query_long straight off the raw query, so only string

 * values (e.g. text=) are decoded here. Returns 1 if the key was present. */

static int query_str(const char *q, const char *key, char *out, size_t cap)

{

    size_t kl = strlen(key);

    const char *p = q;

    while (p && *p) {

        if (!strncmp(p, key, kl) && p[kl] == '=') {

            const char *v = p + kl + 1;

            const char *e = strchr(v, '&');

            const char *end = e ? e : v + strlen(v);

            size_t w = 0;

            for (const char *r = v; r < end && w + 1 < cap; ) {

                int hi, lo;

                if (r[0] == '%' && r + 2 < end &&

                    (hi = hex_nibble(r[1])) >= 0 && (lo = hex_nibble(r[2])) >= 0) {

                    out[w++] = (char)((hi << 4) | lo);

                    r += 3;

                } else if (r[0] == '+') {

                    out[w++] = ' ';

                    r += 1;

                } else {

                    out[w++] = *r++;

                }

            }

            out[w] = 0;

            return 1;

        }

        p = strchr(p, '&');

        if (p) p++;

    }

    if (cap) out[0] = 0;

    return 0;

}

/* marshal a read to the emulator thread, wait, send the response. */

static void do_marshalled(int fd, req_t r)

{

    pthread_mutex_lock(&g_lock);

    g_resp_ready = 0; g_resp_body = NULL; g_resp_len = 0;

    g_req = r;

    while (!g_resp_ready) pthread_cond_wait(&g_cv, &g_lock);

    uint8_t *body = g_resp_body; size_t len = g_resp_len;

    int st = g_resp_status; const char *ct = g_resp_ctype;

    char extra[64]; memcpy(extra, g_resp_extra, sizeof extra);

    g_resp_body = NULL;

    pthread_mutex_unlock(&g_lock);

    send_http(fd, st, ct, body, len, extra[0] ? extra : NULL);

    free(body);

}

static void do_status(int fd)

{