/* test_json.c - JSON 解析器/序列化器 单元测试 */
#include "json.h"
#include "util.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

static int failures = 0;
static int checks = 0;

#define CHECK(cond, ...)                                                        \
    do {                                                                        \
        checks++;                                                               \
        if (!(cond)) {                                                          \
            failures++;                                                         \
            printf("  ✗ %s:%d: ", __FILE__, __LINE__);                          \
            printf(__VA_ARGS__);                                                \
            printf("\n");                                                       \
        }                                                                       \
    } while (0)

static void test_basic(void)
{
    puts("test_basic");
    char err[256];
    JsonValue *v = json_parse("{\"a\": 1, \"b\": [true, false, null], \"c\": \"hi\"}",
                              err, sizeof err);
    CHECK(v != NULL, "解析失败: %s", err);
    if (!v) return;
    CHECK(json_get_number(v, "a", -1) == 1, "a 应为 1");
    CHECK(json_array_size(json_object_get(v, "b")) == 3, "b 应有 3 个元素");
    CHECK(json_bool_value(json_array_get(json_object_get(v, "b"), 0), 0) == 1,
          "b[0] 应为 true");
    CHECK(json_array_get(json_object_get(v, "b"), 2)->type == JSON_NULL,
          "b[2] 应为 null");
    CHECK(strcmp(json_get_string(v, "c"), "hi") == 0, "c 应为 hi");

    char *dump = json_dump(v);
    JsonValue *v2 = json_parse(dump, err, sizeof err);
    CHECK(v2 != NULL, "往返解析失败: %s", err);
    char *dump2 = json_dump(v2);
    CHECK(strcmp(dump, dump2) == 0, "往返不一致:\n  %s\n  %s", dump, dump2);
    free(dump); free(dump2);
    json_free(v); json_free(v2);
}

static void test_escapes(void)
{
    puts("test_escapes");
    char err[256];
    JsonValue *v = json_parse("\"a\\nb\\t\\\"c\\\\d\\u4e2d\\u6587\\uD83D\\uDE00\"",
                              err, sizeof err);
    CHECK(v != NULL, "解析失败: %s", err);
    if (!v) return;
    const char *s = json_string_value(v);
    CHECK(strcmp(s, "a\nb\t\"c\\d中文😀") == 0, "转义解码错误: [%s]", s);

    char *q = json_quote_string(s);
    JsonValue *v2 = json_parse(q, err, sizeof err);
    CHECK(v2 != NULL, "转义往返失败: %s / %s", q, err);
    CHECK(v2 && strcmp(json_string_value(v2), s) == 0, "转义往返内容不一致");
    free(q);
    json_free(v); json_free(v2);
}

static void test_numbers(void)
{
    puts("test_numbers");
    char err[256];
    JsonValue *v = json_parse("[0, -1, 3.5, 1e3, -2.5e-2, 123456789012]", err, sizeof err);
    CHECK(v != NULL, "解析失败: %s", err);
    if (!v) return;
    CHECK(json_number_value(json_array_get(v, 0), -1) == 0, "[0]");
    CHECK(json_number_value(json_array_get(v, 1), 0) == -1, "[1]");
    CHECK(json_number_value(json_array_get(v, 2), 0) == 3.5, "[2]");
    CHECK(json_number_value(json_array_get(v, 3), 0) == 1000, "[3]");
    CHECK(json_number_value(json_array_get(v, 4), 0) == -0.025, "[4]");
    CHECK(json_number_value(json_array_get(v, 5), 0) == 123456789012.0, "[5]");
    json_free(v);

    /* 严格按 RFC 8259 扫描数字：这些以前全都被接受 —— strtod 会把 "1e" 读成 1、
     * "5." 读成 5，于是一个手写错的数字会被静默当成另一个数用下去（配置文件、
     * 存档都是手写的，用户只会在很久之后从一个不相干的现象里发现它）。 */
    const char *bad_nums[] = {
        "01", "-01", "5.", ".5", "+1", "1e", "1e+", "1e-", "1.2e", "-", "1_000",
    };
    for (size_t i = 0; i < sizeof bad_nums / sizeof bad_nums[0]; i++) {
        JsonValue *b = json_parse(bad_nums[i], err, sizeof err);
        CHECK(b == NULL, "非法数字应被拒绝: [%s]", bad_nums[i]);
        json_free(b);
    }
    /* 边界上合法的写法不能被误伤 */
    const char *ok_nums[] = {
        "0", "-0", "0.0", "10", "-1.5", "1e3", "1E3", "1e+3", "1e-3", "0.1e10",
        "123456789012345678901234567890", "1e308",
    };
    for (size_t i = 0; i < sizeof ok_nums / sizeof ok_nums[0]; i++) {
        JsonValue *g = json_parse(ok_nums[i], err, sizeof err);
        CHECK(g != NULL && g->type == JSON_NUMBER,
              "合法数字被拒: [%s] (%s)", ok_nums[i], err);
        json_free(g);
    }
}

static void test_invalid(void)
{
    puts("test_invalid");
    char err[256];
    const char *bad[] = {
        "{", "}", "[1,]", "{\"a\":}", "\"unterminated", "tru", "{\"a\" 1}",
        "[1 2]", "01abc", "", "  ", "{\"a\":1}}", "[1,2] extra",
    };
    for (size_t i = 0; i < sizeof bad / sizeof bad[0]; i++) {
        JsonValue *v = json_parse(bad[i], err, sizeof err);
        CHECK(v == NULL, "应当解析失败但成功了: [%s]", bad[i]);
        json_free(v);
    }
    /* 空字符串是合法 JSON 字符串 */
    JsonValue *e = json_parse("\"\"", err, sizeof err);
    CHECK(e != NULL && strcmp(json_string_value(e), "") == 0, "空字符串应为合法");
    json_free(e);
}

static void test_builders(void)
{
    puts("test_builders");
    JsonValue *o = json_new_object();
    json_object_set_string(o, "model", "gpt-x");
    json_object_set_number(o, "n", 3);
    json_object_set_bool(o, "ok", 1);
    JsonValue *arr = json_new_array();
    json_array_push(arr, json_new_string("a"));
    json_array_push(arr, json_new_string("b"));
    json_object_set(o, "items", arr);
    json_object_set_string(o, "model", "gpt-y");   /* 覆盖 */

    char *s = json_dump(o);
    CHECK(strcmp(s, "{\"model\":\"gpt-y\",\"n\":3,\"ok\":true,\"items\":[\"a\",\"b\"]}") == 0,
          "构造结果不对: %s", s);
    free(s);

    /* clone 独立性 */
    JsonValue *c = json_clone(o);
    json_object_set_string(o, "model", "changed");
    CHECK(strcmp(json_get_string(c, "model"), "gpt-y") == 0, "clone 应相互独立");
    json_object_remove(o, "model");
    CHECK(json_object_get(o, "model") == NULL, "remove 应删除键");
    json_free(o); json_free(c);
}

static void test_nested_depth(void)
{
    puts("test_nested_depth");
    char err[256];
    size_t n = 300;
    char *deep = xmalloc(n * 2 + 1);
    for (size_t i = 0; i < n; i++) deep[i] = '[';
    for (size_t i = 0; i < n; i++) deep[n + i] = ']';
    deep[n * 2] = '\0';
    JsonValue *v = json_parse(deep, err, sizeof err);
    CHECK(v == NULL, "超深嵌套应被拒绝");
    free(deep);

    JsonValue *ok = json_parse("[[[1]]]", err, sizeof err);
    CHECK(ok != NULL, "正常嵌套应成功");
    json_free(ok);
}

/* 报错必须能定位：只有"语法错了"而不知道错在哪，等于没有报错 */
static void test_error_location(void)
{
    puts("test_error_location");
    char err[256];
    JsonValue *v;

    /* 尾随逗号：行号必须指向真正出问题的那一行 */
    v = json_parse("{\n  \"a\": 1,\n}\n", err, sizeof err);
    CHECK(v == NULL, "尾随逗号应报错");
    CHECK(strstr(err, "第 3 行") != NULL, "应报出行号: %s", err);
    CHECK(strstr(err, "期望对象的键") != NULL, "应说明期望什么: %s", err);
    CHECK(strstr(err, "}") != NULL, "应回显出错处原文: %s", err);
    json_free(v);

    /* 未闭合的数组：位置应指向输入结束处 */
    v = json_parse("[1, 2\n", err, sizeof err);
    CHECK(v == NULL, "未闭合数组应报错");
    CHECK(strstr(err, "第 2 行") != NULL, "未闭合应指向结尾: %s", err);
    CHECK(strstr(err, "结束") != NULL, "应说明输入在此结束: %s", err);
    json_free(v);

    /* 缺冒号 */
    v = json_parse("{\"a\" 1}", err, sizeof err);
    CHECK(v == NULL, "缺冒号应报错");
    CHECK(strstr(err, "第 1 行") && strstr(err, "':'") != NULL, "缺冒号: %s", err);
    json_free(v);

    /* 尾部多余内容 */
    v = json_parse("{\"a\": 1} extra", err, sizeof err);
    CHECK(v == NULL, "尾部多余内容应报错");
    CHECK(strstr(err, "多余") != NULL, "应说明是多余内容: %s", err);
    json_free(v);

    /* 非法字符要被回显出来 */
    v = json_parse("{\n  \"a\": @\n}", err, sizeof err);
    CHECK(v == NULL, "非法字符应报错");
    CHECK(strstr(err, "@") != NULL, "应回显非法字符: %s", err);
    CHECK(strstr(err, "第 2 行") != NULL, "行号应为第 2 行: %s", err);
    json_free(v);

    /* 控制字符不能被原样吐到终端上 */
    v = json_parse("{\"a\": \x01\x02}", err, sizeof err);
    CHECK(v == NULL, "控制字符应报错");
    CHECK(strchr(err, '\x01') == NULL, "错误信息里不应含原始控制字符");
    json_free(v);

    /* 合法输入不受影响 */
    v = json_parse("{\"a\": [1, {\"b\": null}]}", err, sizeof err);
    CHECK(v != NULL, "合法输入不应报错: %s", err);
    json_free(v);
}

/* 序列化出去的东西必须是**合法 UTF-8**。
 *
 * 服务端会因为请求体里有非法 UTF-8 直接回
 *     400 ... invalid unicode code point
 * 而那段坏数据一旦进了对话历史，之后每次请求都会失败 —— 除非丢掉整轮对话。
 * 坏字节的来源很日常：某条命令在非 UTF-8 locale 下打出来的路径、被截断的多
 * 字节字符、二进制垃圾。所以这条不能只靠"在入口清理"，必须在序列化器这层兜住：
 * 出口是唯一能保证"发出去的永远合法"的地方。
 *
 * 这个校验函数故意用 utf8_seq_len 自己走一遍，而不是信任 dump 的实现 ——
 * 断言的是**产物**的性质，不是实现的自述。 */
static int utf8_all_valid(const char *s)
{
    size_t n = strlen(s), i = 0;
    while (i < n) {
        size_t adv = utf8_seq_len(s + i, n - i);
        if (adv == 0) return 0;
        i += adv;
    }
    return 1;
}

static void test_dump_utf8_safety(void)
{
    puts("test_dump_utf8_safety");

    /* utf8_seq_len：合法序列返回长度 */
    CHECK(utf8_seq_len("\xe4\xb8\xad", 3) == 3, "合法 CJK 应是 3 字节");
    CHECK(utf8_seq_len("A", 1) == 1, "ASCII 应是 1 字节");
    CHECK(utf8_seq_len("\xf0\x9f\x98\x80", 4) == 4, "emoji 应是 4 字节");
    CHECK(utf8_seq_len("\xc2\x80", 2) == 2, "U+0080 的 2 字节编码应合法");

    /* 非法的一律返回 0 */
    CHECK(utf8_seq_len("\x80", 1) == 0, "孤立续字节应非法");
    CHECK(utf8_seq_len("\xe4\xb8", 2) == 0, "被截断的序列应非法");
    CHECK(utf8_seq_len("\xc0\xaf", 2) == 0, "过长编码应非法");
    CHECK(utf8_seq_len("\xed\xa0\x80", 3) == 0, "UTF-16 代理区应非法");
    CHECK(utf8_seq_len("\xf5\x80\x80\x80", 4) == 0, "超出 U+10FFFF 应非法");
    CHECK(utf8_seq_len("\xe4\x41\x42", 3) == 0, "续字节格式不对应非法");

    /* 各种坏字节经 json_dump 之后，整份输出必须是合法 UTF-8 */
    static const char *bad[] = {
        "a\x80" "b",                /* 孤立续字节 */
        "a\xe4\xb8" "b",            /* 截断的 3 字节序列 */
        "a\xc0\xaf" "b",            /* 过长编码（历史上被用来夹带 '/'） */
        "a\xed\xa0\x80" "b",        /* UTF-16 代理区 */
        "a\xf5\x80\x80\x80" "b",    /* 超出 U+10FFFF */
        "\xff\xfe",                 /* 二进制垃圾 */
        "\xe4\xb8\xad\x80\xe6",     /* 合法中文里夹一个坏字节 */
    };
    for (size_t k = 0; k < sizeof bad / sizeof bad[0]; k++) {
        JsonValue *o = json_new_object();
        json_object_set_string(o, "content", bad[k]);
        char *d = json_dump(o);
        CHECK(utf8_all_valid(d), "第 %zu 个坏输入序列化后仍含非法 UTF-8: %s", k, d);
        /* 而且我们的解析器（和服务端一样严格）必须收得下 */
        char err[256];
        JsonValue *back = json_parse(d, err, sizeof err);
        CHECK(back != NULL, "第 %zu 个输出无法解析回来: %s", k, err);
        if (back) {
            const char *got = json_get_string(back, "content");
            CHECK(got && strstr(got, "\xef\xbf\xbd") != NULL,
                  "第 %zu 个输出里应出现 U+FFFD 替换字符", k);
            json_free(back);
        }
        free(d);
        json_free(o);
    }

    /* 合法的多字节内容必须**原样保留** —— 别把好数据一起误伤 */
    JsonValue *o = json_new_object();
    json_object_set_string(o, "content", "中文 😀 tail");
    char *d = json_dump(o);
    CHECK(strstr(d, "中文") != NULL, "合法中文不该被改动: %s", d);
    CHECK(strstr(d, "\xf0\x9f\x98\x80") != NULL, "合法 emoji 不该被改动: %s", d);
    CHECK(strstr(d, "\xef\xbf\xbd") == NULL, "合法输入不该出现替换字符: %s", d);
    free(d);
    json_free(o);
}

int main(void)
{
    test_basic();
    test_escapes();
    test_numbers();
    test_invalid();
    test_builders();
    test_nested_depth();
    test_error_location();
    test_dump_utf8_safety();
    printf("\n%d 项检查，%d 项失败\n", checks, failures);
    return failures ? 1 : 0;
}