#include <inttypes.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>

#include "esp_log.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "mbedtls/sha256.h"
#include "cJSON.h"
#include "secp256k1.h"
#include "secp256k1_extrakeys.h"
#include "secp256k1_schnorrsig.h"

#include "bech32.h"
#include "buttons.h"
#include "display.h"
#include "key_derivation.h"
#include "mnemonic.h"
#include "usb_transport.h"
#include "ui.h"
#include "secure_mem.h"
#include "nip004.h"
#include "nip044.h"
#include "nostr_common.h"

#define FIRMWARE_VERSION "0.0.1"
#ifndef GIT_HASH
#define GIT_HASH "dev"
#endif

static const char *TAG = "nsigner";

#define APPROVAL_TIMEOUT_MS 30000

typedef enum {
    APPROVAL_DENY = 0,
    APPROVAL_ONCE = 1,
    APPROVAL_ALWAYS = 2,
    APPROVAL_TIMEOUT = 3,
} approval_decision_t;

static bool s_always_allow_sign = false;

#define AUTH_REQUIRED 1
#define AUTH_KIND 27235
#define AUTH_NONCE_CACHE 32
static uint8_t s_nonce_cache[AUTH_NONCE_CACHE][32];
static int s_nonce_count = 0;
static int s_nonce_next = 0;

#define AUTH_ERR_ENVELOPE_MALFORMED 2010
#define AUTH_ERR_BODY_MISMATCH 2011
#define AUTH_ERR_SIGNATURE_INVALID 2012
#define AUTH_ERR_KIND_INVALID 2013
#define AUTH_ERR_ENVELOPE_REQUIRED 2014
#define AUTH_ERR_REPLAY_DETECTED 2017

/* Keep large buffers off the main task stack (ESP32-S3 default stack is limited). */
static char s_mnemonic[256];
static uint8_t s_seed[64];
static uint8_t s_privkey[32];
static uint8_t s_pubkey[32];
static char s_npub[128];
static char s_npub_short[40];
static char s_mnemonic_short[64];
static uint8_t s_frame_buf[4096];
static char s_pubkey_hex[65];
static char s_response_buf[2048];
static char s_signed_event_buf[1600];

static char s_encrypt_buf[1600];

static int transport_init(void)
{
    return usb_transport_init();
}

static approval_decision_t wait_for_approval(uint32_t timeout_ms)
{
    btn_event_t evt = buttons_wait(timeout_ms);

    if (evt.kind == BTN_EVT_NONE) {
        return APPROVAL_TIMEOUT;
    }

    if (evt.id == BTN_D0) {
        return APPROVAL_DENY;
    }
    if (evt.id == BTN_D1) {
        return APPROVAL_ONCE;
    }
    if (evt.id == BTN_D2) {
        return APPROVAL_ALWAYS;
    }

    return APPROVAL_TIMEOUT;
}

static void show_approval_prompt_with_caller(const cJSON *event_in, const char *caller_pubkey_hex)
{
    char line_caller[32];
    char line_kind[32];
    char line_content[64];
    int kind = 1;
    const char *content = "";
    const cJSON *kind_item = cJSON_GetObjectItemCaseSensitive((cJSON *)event_in, "kind");
    const cJSON *content_item = cJSON_GetObjectItemCaseSensitive((cJSON *)event_in, "content");

    if (cJSON_IsNumber(kind_item)) {
        kind = kind_item->valueint;
    }
    if (cJSON_IsString(content_item) && content_item->valuestring != NULL) {
        content = content_item->valuestring;
    }

    if (caller_pubkey_hex != NULL && strlen(caller_pubkey_hex) >= 12) {
        snprintf(line_caller, sizeof(line_caller), "from:%.6s..%.4s",
                 caller_pubkey_hex, caller_pubkey_hex + strlen(caller_pubkey_hex) - 4);
    } else {
        snprintf(line_caller, sizeof(line_caller), "from:%.20s",
                 caller_pubkey_hex ? caller_pubkey_hex : "anon");
    }

    snprintf(line_kind, sizeof(line_kind), "kind: %d", kind);
    snprintf(line_content, sizeof(line_content), "%.50s", content);

    display_clear(RGB565_BLACK);
    display_draw_text(10, 10, "APPROVE sign_event?", RGB565_RED, RGB565_BLACK);
    display_draw_text(10, 24, line_caller, RGB565_WHITE, RGB565_BLACK);
    display_draw_text(10, 40, line_kind, RGB565_WHITE, RGB565_BLACK);
    display_draw_text(10, 56, line_content, RGB565_WHITE, RGB565_BLACK);
    display_draw_text(10, 80, "D1=allow once", RGB565_DIM_GRAY, RGB565_BLACK);
    display_draw_text(10, 96, "D2=always allow", RGB565_DIM_GRAY, RGB565_BLACK);
    display_draw_text(10, 112, "D0=deny", RGB565_DIM_GRAY, RGB565_BLACK);
}

static void show_idle_screen(void)
{
    display_clear(RGB565_BLACK);
    display_draw_text(10, 10, "nostr npub", RGB565_WHITE, RGB565_BLACK);
    display_draw_text(10, 30, s_npub_short, RGB565_WHITE, RGB565_BLACK);
    display_draw_text(10, 50, "mn:", RGB565_WHITE, RGB565_BLACK);
    display_draw_text(46, 50, s_mnemonic_short, RGB565_WHITE, RGB565_BLACK);
    display_draw_text(10, 70, "v" FIRMWARE_VERSION, RGB565_DIM_GRAY, RGB565_BLACK);
    display_draw_text(10, 90, "ready", RGB565_DIM_GRAY, RGB565_BLACK);
}

static int recv_frame_stdin(uint8_t *payload, size_t payload_max, size_t *out_len)
{
    return cdc_recv_frame(payload, payload_max, out_len);
}

static int send_frame_stdout(const uint8_t *payload, size_t len)
{
    return cdc_send_frame(payload, len);
}

static void format_npub_short(const char *npub, char *out, size_t out_len)
{
    size_t len;

    if (out == NULL || out_len == 0) {
        return;
    }

    if (npub == NULL) {
        out[0] = '\0';
        return;
    }

    len = strlen(npub);
    if (len <= 22) {
        memcpy(out, npub, len + 1);
        return;
    }

    snprintf(out, out_len, "%.11s...%s", npub, npub + len - 6);
}

static void format_mnemonic_short(const char *mnemonic, char *out, size_t out_len)
{
    size_t copied = 0;
    int spaces_seen = 0;

    if (out == NULL || out_len == 0) {
        return;
    }

    out[0] = '\0';

    if (mnemonic == NULL) {
        return;
    }

    while (*mnemonic != '\0' && copied + 1 < out_len) {
        out[copied++] = *mnemonic;
        if (*mnemonic == ' ') {
            spaces_seen++;
            if (spaces_seen >= 3) {
                break;
            }
        }
        mnemonic++;
    }

    if (copied >= 4 && copied + 3 < out_len) {
        out[copied++] = '.';
        out[copied++] = '.';
        out[copied++] = '.';
    }

    out[copied] = '\0';
}

static void bytes_to_hex(const uint8_t *in, size_t in_len, char *out, size_t out_len)
{
    static const char hex[] = "0123456789abcdef";
    size_t i;

    if (in == NULL || out == NULL || out_len < (in_len * 2U + 1U)) {
        return;
    }

    for (i = 0; i < in_len; ++i) {
        out[i * 2U] = hex[(in[i] >> 4) & 0x0F];
        out[i * 2U + 1U] = hex[in[i] & 0x0F];
    }
    out[in_len * 2U] = '\0';
}

static int extract_json_id_token(const char *json, char *out, size_t out_len)
{
    const char *id_pos;
    const char *p;
    size_t n = 0;

    if (json == NULL || out == NULL || out_len < 5) {
        return -1;
    }

    id_pos = strstr(json, "\"id\"");
    if (id_pos == NULL) {
        return -1;
    }

    p = strchr(id_pos, ':');
    if (p == NULL) {
        return -1;
    }
    ++p;
    while (*p != '\0' && isspace((unsigned char)*p)) {
        ++p;
    }

    if (*p == '\"') {
        out[n++] = '\"';
        ++p;
        while (*p != '\0' && *p != '\"' && n + 2 < out_len) {
            out[n++] = *p++;
        }
        if (*p != '\"') {
            return -1;
        }
        out[n++] = '\"';
        out[n] = '\0';
        return 0;
    }

    while (*p != '\0' && *p != ',' && *p != '}' && !isspace((unsigned char)*p) && n + 1 < out_len) {
        out[n++] = *p++;
    }

    if (n == 0) {
        return -1;
    }

    out[n] = '\0';
    return 0;
}

static int extract_json_string_field(const char *json, const char *field, char *out, size_t out_len)
{
    char key[48];
    const char *pos;
    const char *p;
    size_t n = 0;

    if (json == NULL || field == NULL || out == NULL || out_len < 2) {
        return -1;
    }

    snprintf(key, sizeof(key), "\"%s\"", field);
    pos = strstr(json, key);
    if (pos == NULL) {
        return -1;
    }

    p = strchr(pos, ':');
    if (p == NULL) {
        return -1;
    }
    ++p;

    while (*p != '\0' && isspace((unsigned char)*p)) {
        ++p;
    }
    if (*p != '\"') {
        return -1;
    }

    ++p;
    while (*p != '\0' && *p != '\"' && n + 1 < out_len) {
        out[n++] = *p++;
    }

    if (*p != '\"' || n == 0) {
        return -1;
    }

    out[n] = '\0';
    return 0;
}

static int sha256_bytes(const uint8_t *in, size_t in_len, uint8_t out32[32])
{
    if (in == NULL || out32 == NULL) {
        return -1;
    }

    mbedtls_sha256(in, in_len, out32, 0);

    return 0;
}

static int build_signed_event_json(const cJSON *event_in,
                                   const char *pubkey_hex,
                                   const uint8_t privkey[32],
                                   char *out,
                                   size_t out_len)
{
    const cJSON *kind_item;
    const cJSON *created_item;
    const cJSON *content_item;
    const cJSON *tags_item;
    int kind = 1;
    int64_t created_at = 0;
    const char *content = "";
    cJSON *ser_arr = NULL;
    cJSON *result_obj = NULL;
    cJSON *tags_dup = NULL;
    char *ser_json = NULL;
    char *result_json = NULL;
    uint8_t id32[32] = {0};
    uint8_t sig64[64] = {0};
    char id_hex[65] = {0};
    char sig_hex[129] = {0};
    int rc = -1;

    if (event_in == NULL || pubkey_hex == NULL || privkey == NULL || out == NULL || out_len == 0) {
        return -1;
    }

    kind_item = cJSON_GetObjectItemCaseSensitive((cJSON *)event_in, "kind");
    created_item = cJSON_GetObjectItemCaseSensitive((cJSON *)event_in, "created_at");
    content_item = cJSON_GetObjectItemCaseSensitive((cJSON *)event_in, "content");
    tags_item = cJSON_GetObjectItemCaseSensitive((cJSON *)event_in, "tags");

    if (cJSON_IsNumber(kind_item)) {
        kind = kind_item->valueint;
    }
    if (cJSON_IsNumber(created_item)) {
        created_at = (int64_t)created_item->valuedouble;
    }
    if (cJSON_IsString(content_item) && content_item->valuestring != NULL) {
        content = content_item->valuestring;
    }

    ser_arr = cJSON_CreateArray();
    if (ser_arr == NULL) {
        goto cleanup;
    }

    cJSON_AddItemToArray(ser_arr, cJSON_CreateNumber(0));
    cJSON_AddItemToArray(ser_arr, cJSON_CreateString(pubkey_hex));
    cJSON_AddItemToArray(ser_arr, cJSON_CreateNumber((double)created_at));
    cJSON_AddItemToArray(ser_arr, cJSON_CreateNumber(kind));

    if (cJSON_IsArray(tags_item)) {
        tags_dup = cJSON_Duplicate((cJSON *)tags_item, 1);
    } else {
        tags_dup = cJSON_CreateArray();
    }
    if (tags_dup == NULL) {
        goto cleanup;
    }
    cJSON_AddItemToArray(ser_arr, tags_dup);
    tags_dup = NULL;

    cJSON_AddItemToArray(ser_arr, cJSON_CreateString(content));

    ser_json = cJSON_PrintUnformatted(ser_arr);
    if (ser_json == NULL) {
        goto cleanup;
    }

    if (sha256_bytes((const uint8_t *)ser_json, strlen(ser_json), id32) != 0) {
        goto cleanup;
    }
    bytes_to_hex(id32, sizeof(id32), id_hex, sizeof(id_hex));

    if (schnorr_sign32(privkey, id32, sig64) != 0) {
        goto cleanup;
    }
    bytes_to_hex(sig64, sizeof(sig64), sig_hex, sizeof(sig_hex));

    result_obj = cJSON_CreateObject();
    if (result_obj == NULL) {
        goto cleanup;
    }

    cJSON_AddStringToObject(result_obj, "id", id_hex);
    cJSON_AddStringToObject(result_obj, "pubkey", pubkey_hex);
    cJSON_AddNumberToObject(result_obj, "created_at", (double)created_at);
    cJSON_AddNumberToObject(result_obj, "kind", kind);
    if (cJSON_IsArray(tags_item)) {
        cJSON_AddItemToObject(result_obj, "tags", cJSON_Duplicate((cJSON *)tags_item, 1));
    } else {
        cJSON_AddItemToObject(result_obj, "tags", cJSON_CreateArray());
    }
    cJSON_AddStringToObject(result_obj, "content", content);
    cJSON_AddStringToObject(result_obj, "sig", sig_hex);

    result_json = cJSON_PrintUnformatted(result_obj);
    if (result_json == NULL) {
        goto cleanup;
    }

    if (strlen(result_json) + 1 > out_len) {
        goto cleanup;
    }

    memcpy(out, result_json, strlen(result_json) + 1);
    rc = 0;

cleanup:
    if (ser_arr != NULL) {
        cJSON_Delete(ser_arr);
    }
    if (result_obj != NULL) {
        cJSON_Delete(result_obj);
    }
    if (tags_dup != NULL) {
        cJSON_Delete(tags_dup);
    }
    if (ser_json != NULL) {
        cJSON_free(ser_json);
    }
    if (result_json != NULL) {
        cJSON_free(result_json);
    }

    memset(id32, 0, sizeof(id32));
    memset(sig64, 0, sizeof(sig64));
    return rc;
}

static int hex_to_bytes(const char *hex, uint8_t *out, size_t out_len)
{
    size_t hex_len;
    size_t i;

    if (hex == NULL || out == NULL) {
        return -1;
    }

    hex_len = strlen(hex);
    if (hex_len != out_len * 2U) {
        return -1;
    }

    for (i = 0; i < out_len; ++i) {
        char hi = hex[i * 2U];
        char lo = hex[i * 2U + 1U];
        int hv, lv;

        if (hi >= '0' && hi <= '9') hv = hi - '0';
        else if (hi >= 'a' && hi <= 'f') hv = 10 + (hi - 'a');
        else if (hi >= 'A' && hi <= 'F') hv = 10 + (hi - 'A');
        else return -1;

        if (lo >= '0' && lo <= '9') lv = lo - '0';
        else if (lo >= 'a' && lo <= 'f') lv = 10 + (lo - 'a');
        else if (lo >= 'A' && lo <= 'F') lv = 10 + (lo - 'A');
        else return -1;

        out[i] = (uint8_t)((hv << 4) | lv);
    }
    return 0;
}

static int auth_replay_check_and_record(const uint8_t id32[32])
{
    int i;
    int slot;

    for (i = 0; i < s_nonce_count; ++i) {
        if (memcmp(s_nonce_cache[i], id32, 32) == 0) {
            return -1;
        }
    }

    slot = s_nonce_next;
    memcpy(s_nonce_cache[slot], id32, 32);
    s_nonce_next = (s_nonce_next + 1) % AUTH_NONCE_CACHE;
    if (s_nonce_count < AUTH_NONCE_CACHE) {
        s_nonce_count++;
    }
    return 0;
}

/*
 * Verify the auth envelope for an inbound JSON-RPC request.
 *
 * Returns:
 *   0  -> envelope valid, caller_pubkey_hex_out filled in (65 bytes incl. NUL)
 *   >0 -> error code (matches AUTH_ERR_* constants)
 *
 * PoC-grade: no wall-clock skew check (no RTC). Replay protection via
 * in-memory nonce cache of recent auth event ids.
 */
static int auth_envelope_verify(cJSON *req,
                                const char *method,
                                char caller_pubkey_hex_out[65])
{
    cJSON *auth_obj = cJSON_GetObjectItemCaseSensitive(req, "auth");
    cJSON *params = cJSON_GetObjectItemCaseSensitive(req, "params");
    cJSON *id_item;
    cJSON *pk_item;
    cJSON *created_item;
    cJSON *kind_item;
    cJSON *tags_item;
    cJSON *content_item;
    cJSON *sig_item;
    cJSON *ser_arr = NULL;
    char *ser_json = NULL;
    char *params_json = NULL;
    char body_hash_hex[65];
    uint8_t computed_id[32];
    uint8_t expected_id[32];
    uint8_t pubkey32[32];
    uint8_t sig64[64];
    secp256k1_xonly_pubkey xonly;
    secp256k1_context *ctx = NULL;
    int rc = AUTH_ERR_ENVELOPE_MALFORMED;
    int found_method = 0;
    int found_body = 0;
    cJSON *tag_entry;
    int kind_value;

    if (auth_obj == NULL || !cJSON_IsObject(auth_obj)) {
        return AUTH_ERR_ENVELOPE_REQUIRED;
    }

    id_item = cJSON_GetObjectItemCaseSensitive(auth_obj, "id");
    pk_item = cJSON_GetObjectItemCaseSensitive(auth_obj, "pubkey");
    created_item = cJSON_GetObjectItemCaseSensitive(auth_obj, "created_at");
    kind_item = cJSON_GetObjectItemCaseSensitive(auth_obj, "kind");
    tags_item = cJSON_GetObjectItemCaseSensitive(auth_obj, "tags");
    content_item = cJSON_GetObjectItemCaseSensitive(auth_obj, "content");
    sig_item = cJSON_GetObjectItemCaseSensitive(auth_obj, "sig");

    if (!cJSON_IsString(id_item) || !cJSON_IsString(pk_item) ||
        !cJSON_IsNumber(created_item) || !cJSON_IsNumber(kind_item) ||
        !cJSON_IsArray(tags_item) || !cJSON_IsString(content_item) ||
        !cJSON_IsString(sig_item)) {
        return AUTH_ERR_ENVELOPE_MALFORMED;
    }

    kind_value = kind_item->valueint;
    if (kind_value != AUTH_KIND) {
        return AUTH_ERR_KIND_INVALID;
    }

    if (hex_to_bytes(id_item->valuestring, expected_id, 32) != 0 ||
        hex_to_bytes(pk_item->valuestring, pubkey32, 32) != 0 ||
        hex_to_bytes(sig_item->valuestring, sig64, 64) != 0) {
        return AUTH_ERR_ENVELOPE_MALFORMED;
    }

    ser_arr = cJSON_CreateArray();
    if (ser_arr == NULL) {
        return AUTH_ERR_ENVELOPE_MALFORMED;
    }
    cJSON_AddItemToArray(ser_arr, cJSON_CreateNumber(0));
    cJSON_AddItemToArray(ser_arr, cJSON_CreateString(pk_item->valuestring));
    cJSON_AddItemToArray(ser_arr, cJSON_CreateNumber(created_item->valuedouble));
    cJSON_AddItemToArray(ser_arr, cJSON_CreateNumber(kind_value));
    cJSON_AddItemToArray(ser_arr, cJSON_Duplicate(tags_item, 1));
    cJSON_AddItemToArray(ser_arr, cJSON_CreateString(content_item->valuestring));

    ser_json = cJSON_PrintUnformatted(ser_arr);
    if (ser_json == NULL) {
        rc = AUTH_ERR_ENVELOPE_MALFORMED;
        goto done;
    }

    mbedtls_sha256((const uint8_t *)ser_json, strlen(ser_json), computed_id, 0);

    if (memcmp(computed_id, expected_id, 32) != 0) {
        rc = AUTH_ERR_ENVELOPE_MALFORMED;
        goto done;
    }

    ctx = secp256k1_context_create(SECP256K1_CONTEXT_VERIFY);
    if (ctx == NULL) {
        rc = AUTH_ERR_SIGNATURE_INVALID;
        goto done;
    }
    if (!secp256k1_xonly_pubkey_parse(ctx, &xonly, pubkey32)) {
        rc = AUTH_ERR_SIGNATURE_INVALID;
        goto done;
    }
    if (!secp256k1_schnorrsig_verify(ctx, sig64, expected_id, 32, &xonly)) {
        rc = AUTH_ERR_SIGNATURE_INVALID;
        goto done;
    }

    {
        cJSON *params_for_hash = params != NULL ? params : cJSON_CreateArray();
        params_json = cJSON_PrintUnformatted(params_for_hash);
    }
    if (params_json == NULL) {
        rc = AUTH_ERR_BODY_MISMATCH;
        goto done;
    }
    {
        uint8_t body_hash[32];
        size_t i;
        static const char hex[] = "0123456789abcdef";

        mbedtls_sha256((const uint8_t *)params_json, strlen(params_json), body_hash, 0);
        for (i = 0; i < 32; ++i) {
            body_hash_hex[i * 2U] = hex[(body_hash[i] >> 4) & 0x0F];
            body_hash_hex[i * 2U + 1U] = hex[body_hash[i] & 0x0F];
        }
        body_hash_hex[64] = '\0';
    }

    cJSON_ArrayForEach(tag_entry, tags_item) {
        cJSON *k_item;
        cJSON *v_item;

        if (!cJSON_IsArray(tag_entry) || cJSON_GetArraySize(tag_entry) < 2) {
            continue;
        }
        k_item = cJSON_GetArrayItem(tag_entry, 0);
        v_item = cJSON_GetArrayItem(tag_entry, 1);
        if (!cJSON_IsString(k_item) || !cJSON_IsString(v_item)) {
            continue;
        }
        if (strcmp(k_item->valuestring, "nsigner_method") == 0 &&
            strcmp(v_item->valuestring, method) == 0) {
            found_method = 1;
        } else if (strcmp(k_item->valuestring, "nsigner_body_hash") == 0 &&
                   strcasecmp(v_item->valuestring, body_hash_hex) == 0) {
            found_body = 1;
        }
    }

    if (!found_method || !found_body) {
        rc = AUTH_ERR_BODY_MISMATCH;
        goto done;
    }

    if (auth_replay_check_and_record(expected_id) != 0) {
        rc = AUTH_ERR_REPLAY_DETECTED;
        goto done;
    }

    memcpy(caller_pubkey_hex_out, pk_item->valuestring, 64);
    caller_pubkey_hex_out[64] = '\0';
    rc = 0;

done:
    if (ser_arr != NULL) {
        cJSON_Delete(ser_arr);
    }
    if (ser_json != NULL) {
        cJSON_free(ser_json);
    }
    if (params_json != NULL) {
        cJSON_free(params_json);
    }
    if (ctx != NULL) {
        secp256k1_context_destroy(ctx);
    }
    return rc;
}

static int parse_nostr_index_from_params(cJSON *params, uint32_t *out_index)
{
    int params_count;
    cJSON *last_item;
    cJSON *idx_item;
    int idx;

    if (out_index == NULL) {
        return -1;
    }

    *out_index = 0;

    if (params == NULL || !cJSON_IsArray(params)) {
        return 0;
    }

    params_count = cJSON_GetArraySize(params);
    if (params_count <= 0) {
        return 0;
    }

    last_item = cJSON_GetArrayItem(params, params_count - 1);
    if (last_item == NULL || !cJSON_IsObject(last_item)) {
        return 0;
    }

    idx_item = cJSON_GetObjectItemCaseSensitive(last_item, "nostr_index");
    if (idx_item == NULL) {
        return 0;
    }
    if (!cJSON_IsNumber(idx_item)) {
        return -1;
    }

    idx = idx_item->valueint;
    if (idx < 0) {
        return -1;
    }

    *out_index = (uint32_t)idx;
    return 0;
}

static int derive_request_key(uint32_t nostr_index, uint8_t privkey_out[32], char pubkey_hex_out[65])
{
    uint8_t pubkey[32];

    if (privkey_out == NULL || pubkey_hex_out == NULL) {
        return -1;
    }

    if (derive_nostr_key_index(s_seed, nostr_index, privkey_out, pubkey) != 0) {
        return -1;
    }

    bytes_to_hex(pubkey, sizeof(pubkey), pubkey_hex_out, 65);
    secure_memzero(pubkey, sizeof(pubkey));
    return 0;
}

static int parse_peer_and_message_params(cJSON *params,
                                         const char **peer_hex_out,
                                         const char **message_out,
                                         uint32_t *nostr_index_out)
{
    cJSON *peer_item;
    cJSON *msg_item;

    if (params == NULL || !cJSON_IsArray(params) ||
        peer_hex_out == NULL || message_out == NULL || nostr_index_out == NULL) {
        return -1;
    }

    if (cJSON_GetArraySize(params) < 2) {
        return -1;
    }

    peer_item = cJSON_GetArrayItem(params, 0);
    msg_item = cJSON_GetArrayItem(params, 1);

    if (!cJSON_IsString(peer_item) || peer_item->valuestring == NULL ||
        !cJSON_IsString(msg_item) || msg_item->valuestring == NULL) {
        return -1;
    }

    if (parse_nostr_index_from_params(params, nostr_index_out) != 0) {
        return -1;
    }

    *peer_hex_out = peer_item->valuestring;
    *message_out = msg_item->valuestring;
    return 0;
}

static int apply_mnemonic_and_enter_working(const char *mnemonic)
{
    if (mnemonic == NULL || mnemonic[0] == '\0') {
        return -1;
    }

    format_mnemonic_short(mnemonic, s_mnemonic_short, sizeof(s_mnemonic_short));

    if (mnemonic_to_seed(mnemonic, s_seed) != 0) {
        ESP_ERROR_CHECK(display_draw_text(10, 50, "seed failed", RGB565_RED, RGB565_BLACK));
        return -1;
    }

    if (derive_nostr_key_index(s_seed, 0u, s_privkey, s_pubkey) != 0) {
        ESP_ERROR_CHECK(display_draw_text(10, 50, "key failed", RGB565_RED, RGB565_BLACK));
        secure_memzero(s_seed, sizeof(s_seed));
        return -1;
    }

    if (npub_encode(s_pubkey, s_npub, sizeof(s_npub)) != 0) {
        ESP_ERROR_CHECK(display_draw_text(10, 50, "npub failed", RGB565_RED, RGB565_BLACK));
        secure_memzero(s_seed, sizeof(s_seed));
        secure_memzero(s_pubkey, sizeof(s_pubkey));
        return -1;
    }

    format_npub_short(s_npub, s_npub_short, sizeof(s_npub_short));
    bytes_to_hex(s_pubkey, sizeof(s_pubkey), s_pubkey_hex, sizeof(s_pubkey_hex));
    printf("Derived npub[0]: %s\n", s_npub);
    printf("Derived pubkey hex[0]: %s\n", s_pubkey_hex);

    show_idle_screen();

    secure_memzero(s_pubkey, sizeof(s_pubkey));
    return 0;
}

static void run_signing_loop(void)
{
    uint32_t rx_frames = 0;
    uint32_t tx_frames = 0;
    size_t last_len = 0;

    while (1) {
        char stat1[32];
        char stat2[32];
        int got_frame = 0;
        int via_webusb = 0;

        if (webusb_recv_frame(s_frame_buf, sizeof(s_frame_buf), &last_len) == 0) {
            got_frame = 1;
            via_webusb = 1;
        } else if (recv_frame_stdin(s_frame_buf, sizeof(s_frame_buf), &last_len) == 0) {
            got_frame = 1;
            via_webusb = 0;
        }

        if (!got_frame) {
            vTaskDelay(pdMS_TO_TICKS(2));
            continue;
        }

        rx_frames++;

        /* Default to a concrete error so every received frame gets a response. */
        snprintf(
            s_response_buf,
            sizeof(s_response_buf),
            "{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{\"code\":-32603,\"message\":\"internal error: unhandled request\"}}");

        if (last_len < sizeof(s_frame_buf)) {
            char id_token[96] = {0};
            char method[64] = {0};
            char caller_pubkey_hex[65] = {0};
            int auth_rc = 0;
            cJSON *req = NULL;

            s_frame_buf[last_len] = '\0';

            if (extract_json_id_token((const char *)s_frame_buf, id_token, sizeof(id_token)) != 0) {
                strncpy(id_token, "null", sizeof(id_token) - 1);
            }

            req = cJSON_Parse((const char *)s_frame_buf);

            if (req == NULL ||
                extract_json_string_field((const char *)s_frame_buf, "method", method, sizeof(method)) != 0) {
                snprintf(
                    s_response_buf,
                    sizeof(s_response_buf),
                    "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32600,\"message\":\"invalid request\"}}",
                    id_token);
            } else {
#if AUTH_REQUIRED
                auth_rc = auth_envelope_verify(req, method, caller_pubkey_hex);
#else
                auth_rc = 0;
                strncpy(caller_pubkey_hex, "anon", sizeof(caller_pubkey_hex) - 1);
#endif

                if (auth_rc != 0) {
                    const char *msg = "auth envelope required";
                    if (auth_rc == AUTH_ERR_ENVELOPE_MALFORMED) msg = "auth envelope malformed";
                    else if (auth_rc == AUTH_ERR_BODY_MISMATCH) msg = "auth body mismatch";
                    else if (auth_rc == AUTH_ERR_SIGNATURE_INVALID) msg = "auth signature invalid";
                    else if (auth_rc == AUTH_ERR_KIND_INVALID) msg = "auth kind invalid";
                    else if (auth_rc == AUTH_ERR_REPLAY_DETECTED) msg = "auth replay detected";

                    snprintf(
                        s_response_buf,
                        sizeof(s_response_buf),
                        "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":%d,\"message\":\"%s\"}}",
                        id_token, auth_rc, msg);
                } else if (strcmp(method, "get_public_key") == 0) {
                    cJSON *params = cJSON_GetObjectItemCaseSensitive(req, "params");
                    uint32_t nostr_index = 0;
                    uint8_t req_privkey[32];
                    char req_pubkey_hex[65];

                    memset(req_privkey, 0, sizeof(req_privkey));
                    memset(req_pubkey_hex, 0, sizeof(req_pubkey_hex));

                    if (!cJSON_IsArray(params) ||
                        parse_nostr_index_from_params(params, &nostr_index) != 0 ||
                        derive_request_key(nostr_index, req_privkey, req_pubkey_hex) != 0) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32602,\"message\":\"invalid params\"}}",
                            id_token);
                    } else {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"result\":\"%s\"}",
                            id_token,
                            req_pubkey_hex);
                    }

                    secure_memzero(req_privkey, sizeof(req_privkey));
                } else if (strcmp(method, "sign_event") == 0) {
                    cJSON *params = cJSON_GetObjectItemCaseSensitive(req, "params");
                    cJSON *event_in = NULL;
                    uint32_t nostr_index = 0;
                    uint8_t req_privkey[32];
                    char req_pubkey_hex[65];

                    memset(req_privkey, 0, sizeof(req_privkey));
                    memset(req_pubkey_hex, 0, sizeof(req_pubkey_hex));

                    if (cJSON_IsArray(params) && cJSON_GetArraySize(params) > 0) {
                        event_in = cJSON_GetArrayItem(params, 0);
                    }

                    if (event_in != NULL && cJSON_IsObject(event_in) &&
                        parse_nostr_index_from_params(params, &nostr_index) == 0 &&
                        derive_request_key(nostr_index, req_privkey, req_pubkey_hex) == 0) {
                        approval_decision_t decision = APPROVAL_ALWAYS;

                        /* Firmware policy: never prompt, always approve sign requests. */
                        s_always_allow_sign = true;

                        if ((decision == APPROVAL_ONCE || decision == APPROVAL_ALWAYS) &&
                            build_signed_event_json(event_in, req_pubkey_hex, req_privkey, s_signed_event_buf, sizeof(s_signed_event_buf)) == 0) {
                            snprintf(
                                s_response_buf,
                                sizeof(s_response_buf),
                                "{\"jsonrpc\":\"2.0\",\"id\":%s,\"result\":%s}",
                                id_token,
                                s_signed_event_buf);
                        } else if (decision == APPROVAL_DENY) {
                            snprintf(
                                s_response_buf,
                                sizeof(s_response_buf),
                                "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32000,\"message\":\"denied by user\"}}",
                                id_token);
                        } else if (decision == APPROVAL_TIMEOUT) {
                            snprintf(
                                s_response_buf,
                                sizeof(s_response_buf),
                                "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32001,\"message\":\"approval timeout\"}}",
                                id_token);
                        } else {
                            snprintf(
                                s_response_buf,
                                sizeof(s_response_buf),
                                "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"internal error\"}}",
                                id_token);
                        }
                    } else {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32602,\"message\":\"invalid params\"}}",
                            id_token);
                    }

                    secure_memzero(req_privkey, sizeof(req_privkey));
                } else if (strcmp(method, "nip04_encrypt") == 0) {
                    cJSON *params = cJSON_GetObjectItemCaseSensitive(req, "params");
                    const char *peer_hex = NULL;
                    const char *plaintext = NULL;
                    uint32_t nostr_index = 0;
                    uint8_t peer_pubkey[32];
                    uint8_t req_privkey[32];
                    char req_pubkey_hex[65];

                    memset(peer_pubkey, 0, sizeof(peer_pubkey));
                    memset(req_privkey, 0, sizeof(req_privkey));
                    memset(req_pubkey_hex, 0, sizeof(req_pubkey_hex));
                    memset(s_encrypt_buf, 0, sizeof(s_encrypt_buf));

                    if (parse_peer_and_message_params(params, &peer_hex, &plaintext, &nostr_index) != 0 ||
                        hex_to_bytes(peer_hex, peer_pubkey, sizeof(peer_pubkey)) != 0 ||
                        derive_request_key(nostr_index, req_privkey, req_pubkey_hex) != 0) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32602,\"message\":\"invalid params\"}}",
                            id_token);
                    } else if (nostr_nip04_encrypt(req_privkey, peer_pubkey, plaintext,
                                                   s_encrypt_buf, sizeof(s_encrypt_buf)) != NOSTR_SUCCESS) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"nip04 encryption failed\"}}",
                            id_token);
                    } else {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"result\":\"%s\"}",
                            id_token,
                            s_encrypt_buf);
                    }

                    secure_memzero(req_privkey, sizeof(req_privkey));
                    secure_memzero(peer_pubkey, sizeof(peer_pubkey));
                } else if (strcmp(method, "nip44_encrypt") == 0) {
                    cJSON *params = cJSON_GetObjectItemCaseSensitive(req, "params");
                    const char *peer_hex = NULL;
                    const char *plaintext = NULL;
                    uint32_t nostr_index = 0;
                    uint8_t peer_pubkey[32];
                    uint8_t req_privkey[32];
                    char req_pubkey_hex[65];

                    memset(peer_pubkey, 0, sizeof(peer_pubkey));
                    memset(req_privkey, 0, sizeof(req_privkey));
                    memset(req_pubkey_hex, 0, sizeof(req_pubkey_hex));
                    memset(s_encrypt_buf, 0, sizeof(s_encrypt_buf));

                    if (parse_peer_and_message_params(params, &peer_hex, &plaintext, &nostr_index) != 0 ||
                        hex_to_bytes(peer_hex, peer_pubkey, sizeof(peer_pubkey)) != 0 ||
                        derive_request_key(nostr_index, req_privkey, req_pubkey_hex) != 0) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32602,\"message\":\"invalid params\"}}",
                            id_token);
                    } else if (nostr_nip44_encrypt(req_privkey, peer_pubkey, plaintext,
                                                   s_encrypt_buf, sizeof(s_encrypt_buf)) != NOSTR_SUCCESS) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"nip44 encryption failed\"}}",
                            id_token);
                    } else {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"result\":\"%s\"}",
                            id_token,
                            s_encrypt_buf);
                    }

                    secure_memzero(req_privkey, sizeof(req_privkey));
                    secure_memzero(peer_pubkey, sizeof(peer_pubkey));
                } else if (strcmp(method, "nip04_decrypt") == 0) {
                    cJSON *params = cJSON_GetObjectItemCaseSensitive(req, "params");
                    const char *peer_hex = NULL;
                    const char *ciphertext = NULL;
                    uint32_t nostr_index = 0;
                    uint8_t peer_pubkey[32];
                    uint8_t req_privkey[32];
                    char req_pubkey_hex[65];

                    memset(peer_pubkey, 0, sizeof(peer_pubkey));
                    memset(req_privkey, 0, sizeof(req_privkey));
                    memset(req_pubkey_hex, 0, sizeof(req_pubkey_hex));
                    memset(s_encrypt_buf, 0, sizeof(s_encrypt_buf));

                    if (parse_peer_and_message_params(params, &peer_hex, &ciphertext, &nostr_index) != 0 ||
                        hex_to_bytes(peer_hex, peer_pubkey, sizeof(peer_pubkey)) != 0 ||
                        derive_request_key(nostr_index, req_privkey, req_pubkey_hex) != 0) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32602,\"message\":\"invalid params\"}}",
                            id_token);
                    } else if (nostr_nip04_decrypt(req_privkey, peer_pubkey, ciphertext,
                                                   s_encrypt_buf, sizeof(s_encrypt_buf)) != NOSTR_SUCCESS) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"nip04 decryption failed\"}}",
                            id_token);
                    } else {
                        cJSON *resp_obj = cJSON_CreateObject();
                        if (resp_obj == NULL) {
                            snprintf(
                                s_response_buf,
                                sizeof(s_response_buf),
                                "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"internal error\"}}",
                                id_token);
                        } else {
                            cJSON_AddStringToObject(resp_obj, "jsonrpc", "2.0");
                            cJSON_AddRawToObject(resp_obj, "id", id_token);
                            cJSON_AddStringToObject(resp_obj, "result", s_encrypt_buf);
                            {
                                char *resp_json = cJSON_PrintUnformatted(resp_obj);
                                if (resp_json != NULL && strlen(resp_json) < sizeof(s_response_buf)) {
                                    memcpy(s_response_buf, resp_json, strlen(resp_json) + 1);
                                } else {
                                    snprintf(
                                        s_response_buf,
                                        sizeof(s_response_buf),
                                        "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"internal error\"}}",
                                        id_token);
                                }
                                if (resp_json != NULL) {
                                    cJSON_free(resp_json);
                                }
                            }
                            cJSON_Delete(resp_obj);
                        }
                    }

                    secure_memzero(req_privkey, sizeof(req_privkey));
                    secure_memzero(peer_pubkey, sizeof(peer_pubkey));
                } else if (strcmp(method, "nip44_decrypt") == 0) {
                    cJSON *params = cJSON_GetObjectItemCaseSensitive(req, "params");
                    const char *peer_hex = NULL;
                    const char *ciphertext = NULL;
                    uint32_t nostr_index = 0;
                    uint8_t peer_pubkey[32];
                    uint8_t req_privkey[32];
                    char req_pubkey_hex[65];

                    memset(peer_pubkey, 0, sizeof(peer_pubkey));
                    memset(req_privkey, 0, sizeof(req_privkey));
                    memset(req_pubkey_hex, 0, sizeof(req_pubkey_hex));
                    memset(s_encrypt_buf, 0, sizeof(s_encrypt_buf));

                    if (parse_peer_and_message_params(params, &peer_hex, &ciphertext, &nostr_index) != 0 ||
                        hex_to_bytes(peer_hex, peer_pubkey, sizeof(peer_pubkey)) != 0 ||
                        derive_request_key(nostr_index, req_privkey, req_pubkey_hex) != 0) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32602,\"message\":\"invalid params\"}}",
                            id_token);
                    } else if (nostr_nip44_decrypt(req_privkey, peer_pubkey, ciphertext,
                                                   s_encrypt_buf, sizeof(s_encrypt_buf)) != NOSTR_SUCCESS) {
                        snprintf(
                            s_response_buf,
                            sizeof(s_response_buf),
                            "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"nip44 decryption failed\"}}",
                            id_token);
                    } else {
                        cJSON *resp_obj = cJSON_CreateObject();
                        if (resp_obj == NULL) {
                            snprintf(
                                s_response_buf,
                                sizeof(s_response_buf),
                                "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"internal error\"}}",
                                id_token);
                        } else {
                            cJSON_AddStringToObject(resp_obj, "jsonrpc", "2.0");
                            cJSON_AddRawToObject(resp_obj, "id", id_token);
                            cJSON_AddStringToObject(resp_obj, "result", s_encrypt_buf);
                            {
                                char *resp_json = cJSON_PrintUnformatted(resp_obj);
                                if (resp_json != NULL && strlen(resp_json) < sizeof(s_response_buf)) {
                                    memcpy(s_response_buf, resp_json, strlen(resp_json) + 1);
                                } else {
                                    snprintf(
                                        s_response_buf,
                                        sizeof(s_response_buf),
                                        "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32603,\"message\":\"internal error\"}}",
                                        id_token);
                                }
                                if (resp_json != NULL) {
                                    cJSON_free(resp_json);
                                }
                            }
                            cJSON_Delete(resp_obj);
                        }
                    }

                    secure_memzero(req_privkey, sizeof(req_privkey));
                    secure_memzero(peer_pubkey, sizeof(peer_pubkey));
                } else {
                    snprintf(
                        s_response_buf,
                        sizeof(s_response_buf),
                        "{\"jsonrpc\":\"2.0\",\"id\":%s,\"error\":{\"code\":-32601,\"message\":\"method not found\"}}",
                        id_token);
                }
            }

            if (req != NULL) {
                cJSON_Delete(req);
            }

            if ((!via_webusb && send_frame_stdout((const uint8_t *)s_response_buf, strlen(s_response_buf)) == 0) ||
                (via_webusb && webusb_send_frame((const uint8_t *)s_response_buf, strlen(s_response_buf)) == 0)) {
                tx_frames++;
            } else {
                ESP_LOGE(TAG, "failed to send JSON-RPC response over %s", via_webusb ? "WebUSB" : "CDC");
            }
        } else {
            snprintf(
                s_response_buf,
                sizeof(s_response_buf),
                "{\"jsonrpc\":\"2.0\",\"id\":null,\"error\":{\"code\":-32600,\"message\":\"request too large\"}}");

            if ((!via_webusb && send_frame_stdout((const uint8_t *)s_response_buf, strlen(s_response_buf)) == 0) ||
                (via_webusb && webusb_send_frame((const uint8_t *)s_response_buf, strlen(s_response_buf)) == 0)) {
                tx_frames++;
            } else {
                ESP_LOGE(TAG, "failed to send oversized-request error over %s", via_webusb ? "WebUSB" : "CDC");
            }
        }

        snprintf(stat1, sizeof(stat1), "rx:%" PRIu32 " tx:%" PRIu32, rx_frames, tx_frames);
        snprintf(stat2, sizeof(stat2), "last:%uB", (unsigned)last_len);
        ESP_ERROR_CHECK(display_fill_rect(10, 110, 220, 24, RGB565_BLACK));
        ESP_ERROR_CHECK(display_draw_text(10, 110, stat1, RGB565_DIM_GRAY, RGB565_BLACK));
        ESP_ERROR_CHECK(display_draw_text(10, 122, stat2, RGB565_DIM_GRAY, RGB565_BLACK));
    }
}

void app_main(void)
{
    ESP_LOGI(TAG, "n_signer v%s booting...", FIRMWARE_VERSION);
    printf("n_signer booting\n");

    ESP_ERROR_CHECK(display_init());
    ESP_ERROR_CHECK(display_clear(RGB565_BLACK));

    memset(s_mnemonic, 0, sizeof(s_mnemonic));
    memset(s_seed, 0, sizeof(s_seed));
    memset(s_privkey, 0, sizeof(s_privkey));
    memset(s_pubkey, 0, sizeof(s_pubkey));
    memset(s_npub, 0, sizeof(s_npub));
    memset(s_npub_short, 0, sizeof(s_npub_short));
    memset(s_mnemonic_short, 0, sizeof(s_mnemonic_short));
    memset(s_frame_buf, 0, sizeof(s_frame_buf));
    memset(s_pubkey_hex, 0, sizeof(s_pubkey_hex));

    if (ui_run_until_working(s_mnemonic) != 0) {
        ESP_ERROR_CHECK(display_clear(RGB565_BLACK));
        ESP_ERROR_CHECK(display_draw_text_centered(56, "UI FAILED", RGB565_RED, RGB565_BLACK));
        return;
    }

    if (apply_mnemonic_and_enter_working(s_mnemonic) != 0) {
        secure_memzero(s_mnemonic, sizeof(s_mnemonic));
        return;
    }

    secure_memzero(s_mnemonic, sizeof(s_mnemonic));
    printf("usb cdc+webusb ready\n");

    /* Prevent log text from corrupting framed transport bytes on this same USB stream. */
    esp_log_level_set("*", ESP_LOG_NONE);

    buttons_init();

    if (transport_init() != 0) {
        ESP_ERROR_CHECK(display_draw_text(10, 90, "cdc init fail", RGB565_RED, RGB565_BLACK));
        while (1) {
            vTaskDelay(pdMS_TO_TICKS(1000));
        }
    }

    if (nostr_init() != NOSTR_SUCCESS) {
        ESP_ERROR_CHECK(display_draw_text(10, 90, "nostr init fail", RGB565_RED, RGB565_BLACK));
        while (1) {
            vTaskDelay(pdMS_TO_TICKS(1000));
        }
    }

    /* WebUSB temporarily disabled to preserve stable USB Serial/JTAG CDC enumeration. */
    run_signing_loop();
}