/* test_tools.c - 工具层测试 */
#include "image.h"
#include "json.h"
#include "tools.h"
#include "util.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.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 char *call(const char *name, const char *args_json, int *is_error) {
    char err[256];
    JsonValue *args = json_parse(args_json, err, sizeof err);
    if (!args) {
        printf("  测试用例 args JSON 非法: %s\n", err);
        exit(2);
    }
    char *r = tool_execute(name, args, is_error);
    json_free(args);
    return r;
}

int main(void) {
    char tmpl[] = "/tmp/ligent_test_XXXXXX";
    char *dir = mkdtemp(tmpl);
    if (!dir) {
        perror("mkdtemp");
        return 2;
    }
    if (chdir(dir) != 0) {
        perror("chdir");
        return 2;
    }

    /* ---- 工具 schema 合法性 ---- */
    puts("tools_schema");
    JsonValue *schema = tools_schema();
    CHECK(json_array_size(schema) == 6, "应有 6 个工具, 实际 %zu",
          json_array_size(schema));
    for (size_t i = 0; i < json_array_size(schema); i++) {
        JsonValue *t = json_array_get(schema, i);
        CHECK(strcmp(json_get_string(t, "type"), "function") == 0, "type");
        JsonValue *fn = json_object_get(t, "function");
        CHECK(json_get_string(fn, "name") != NULL, "缺 name");
        JsonValue *params = json_object_get(fn, "parameters");
        CHECK(json_get_string(params, "type") != NULL, "缺 parameters.type");
        CHECK(json_object_get(params, "properties") != NULL, "缺 properties");
        CHECK(json_object_get(params, "required") != NULL, "缺 required");
    }
    {
        int has_image = 0;
        for (size_t i = 0; i < json_array_size(schema); i++) {
            JsonValue *fn =
                json_object_get(json_array_get(schema, i), "function");
            const char *nm = json_get_string(fn, "name");
            if (nm && strcmp(nm, "read_image") == 0)
                has_image = 1;
        }
        CHECK(has_image, "schema 里应有 read_image");
    }
    {
        /* line 是集合型参数: schema 里必须是 array (元素 integer),
         * 否则模型根本不会想到可以给数组 —— 参数表的 "integer[]" 写法
         * 只有 schema 展开对了才作数 */
        JsonValue *props = NULL, *reqd = NULL;
        for (size_t i = 0; i < json_array_size(schema); i++) {
            JsonValue *fn =
                json_object_get(json_array_get(schema, i), "function");
            const char *nm = json_get_string(fn, "name");
            if (nm && strcmp(nm, "edit_file") == 0) {
                JsonValue *par = json_object_get(fn, "parameters");
                props = json_object_get(par, "properties");
                reqd = json_object_get(par, "required");
            }
        }
        /* line 是可选的 (省略 = 全文件替换), 不该出现在 required 里 */
        int line_required = 0;
        for (size_t i = 0; i < json_array_size(reqd); i++) {
            const char *nm = json_string_value(json_array_get(reqd, i));
            if (nm && strcmp(nm, "line") == 0)
                line_required = 1;
        }
        CHECK(!line_required, "line 可以省略 (= 全文件替换), 不该是 required");

        JsonValue *line = props ? json_object_get(props, "line") : NULL;
        const char *lt = line ? json_get_string(line, "type") : NULL;
        CHECK(lt && strcmp(lt, "array") == 0,
              "edit_file 的 line 应是 array, 实际 %s", lt ? lt : "(缺)");
        JsonValue *items = line ? json_object_get(line, "items") : NULL;
        const char *it = items ? json_get_string(items, "type") : NULL;
        CHECK(it && strcmp(it, "integer") == 0,
              "line 的元素应是 integer, 实际 %s", it ? it : "(缺)");
    }

    /* 序列化一遍确保可发给服务端 */
    char *schema_json = json_dump(schema);
    JsonValue *re = json_parse(schema_json, NULL, 0);
    CHECK(re != NULL, "schema 无法被自身解析器往返");
    free(schema_json);
    json_free(re);
    json_free(schema);

    /* ---- run_command ---- */
    puts("run_command");
    int err = 0;
    char *r = call("run_command", "{\"command\":\"echo hello\"}", &err);
    CHECK(err == 0, "exit 0 不应算错误: %s", r);
    CHECK(strstr(r, "hello") != NULL, "应含 hello: %s", r);
    CHECK(strstr(r, "[exit code: 0]") != NULL, "应含退出码: %s", r);
    free(r);

    r = call("run_command", "{\"command\":\"exit 3\"}", &err);
    CHECK(err == 1, "非零退出应标记为错误");
    CHECK(strstr(r, "[exit code: 3]") != NULL, "应报告退出码 3: %s", r);
    free(r);

    r = call("run_command", "{\"command\":\"echo err >&2; exit 1\"}", &err);
    CHECK(strstr(r, "err") != NULL, "stderr 应被合并捕获: %s", r);
    free(r);

    /* 超时 */
    r = call("run_command", "{\"command\":\"sleep 5\",\"timeout\":1}", &err);
    CHECK(err == 1 && strstr(r, "超时") != NULL, "应超时: %s", r);
    free(r);

    r = call("run_command", "{}", &err);
    CHECK(err == 1 && strstr(r, "command") != NULL, "缺参数应报错: %s", r);
    free(r);

    /* ---- write_file / read_file ---- */
    puts("write_file / read_file");
    r = call(
        "write_file",
        "{\"path\":\"sub/dir/a.txt\",\"content\":\"line1\\nline2\\nline3\\n\"}",
        &err);
    CHECK(err == 0, "写入应成功: %s", r);
    CHECK(access("sub/dir/a.txt", R_OK) == 0, "父目录应被自动创建");
    free(r);

    r = call("read_file", "{\"path\":\"sub/dir/a.txt\"}", &err);
    CHECK(err == 0, "读取应成功: %s", r);
    CHECK(strstr(r, "line1") && strstr(r, "line3"), "内容应完整: %s", r);
    CHECK(strstr(r, "1\t") != NULL, "应带行号: %s", r);
    free(r);

    r = call("read_file",
             "{\"path\":\"sub/dir/a.txt\",\"offset\":2,\"limit\":1}", &err);
    CHECK(strstr(r, "line2") && !strstr(r, "line1") && !strstr(r, "line3"),
          "offset/limit 应生效: %s", r);
    free(r);

    r = call("read_file", "{\"path\":\"does_not_exist\"}", &err);
    CHECK(err == 1, "读不存在的文件应报错: %s", r);
    free(r);

    /* ---- edit_file: 替换由行号钉住 ---- */
    puts("edit_file");
    r = call("edit_file",
             "{\"path\":\"sub/dir/a.txt\",\"line\":2,\"old_string\":\"line2\","
             "\"new_string\":\"LINE-TWO\"}",
             &err);
    CHECK(err == 0, "按行号替换应成功: %s", r);
    CHECK(strstr(r, "第 2 行") != NULL, "回执里应带上行号: %s", r);
    free(r);
    r = call("read_file", "{\"path\":\"sub/dir/a.txt\"}", &err);
    CHECK(strstr(r, "LINE-TWO") != NULL, "替换结果应落盘: %s", r);
    free(r);

    /* 省略 line 不再是错误: 那是"全文件替换"这条逃生门 (见下面那组用例) */

    /* 行号对不上: 必须报出它**真正在哪一行**, 否则模型只能反复猜 */
    r = call(
        "edit_file",
        "{\"path\":\"sub/dir/a.txt\",\"line\":3,\"old_string\":\"LINE-TWO\","
        "\"new_string\":\"x\"}",
        &err);
    CHECK(err == 1, "行号不对应报错: %s", r);
    CHECK(strstr(r, "第 2 行") != NULL, "应指出它真正的行号: %s", r);
    free(r);

    /* 越界行号: 要连文件总行数一起说清楚 */
    r = call("edit_file",
             "{\"path\":\"sub/dir/a.txt\",\"line\":99,\"old_string\":\"x\","
             "\"new_string\":\"y\"}",
             &err);
    CHECK(err == 1 && strstr(r, "只有 3 行") != NULL,
          "越界行号应报错并给出总行数: %s", r);
    free(r);

    /* 唯一性只要求**在这一行里**唯一: 同一个词出现在别的行不该拦住替换
     *  (这正是"全文唯一"最烦人的地方——文件一长, 随便一个短串都不唯一) */
    r = call("edit_file",
             "{\"path\":\"sub/dir/a.txt\",\"line\":1,\"old_string\":\"line\","
             "\"new_string\":\"LINE\"}",
             &err);
    CHECK(err == 0, "同一行里唯一即可, 别的行的重复不该拦: %s", r);
    free(r);

    /* 同一行里出现两处 → 仍然拒绝 (行内也要定得下来) */
    r = call("write_file", "{\"path\":\"dup.txt\",\"content\":\"foo foo\\n\"}",
             &err);
    CHECK(err == 0, "写入 dup.txt: %s", r);
    free(r);
    r = call("edit_file",
             "{\"path\":\"dup.txt\",\"line\":1,\"old_string\":\"foo\",\"new_"
             "string\":\"bar\"}",
             &err);
    CHECK(err == 1 && strstr(r, "第 1 行里有 2 处") != NULL,
          "同一行里多匹配应拒绝: %s", r);
    free(r);

    /* replace_all 仍然换全文件, 但 line 必须指向其中真实的一处 */
    r = call("edit_file",
             "{\"path\":\"dup.txt\",\"line\":1,\"old_string\":\"foo\",\"new_"
             "string\":\"bar\","
             "\"replace_all\":true}",
             &err);
    CHECK(err == 0, "replace_all 应成功: %s", r);
    free(r);
    r = call("read_file", "{\"path\":\"dup.txt\"}", &err);
    CHECK(strstr(r, "bar bar") != NULL && !strstr(r, "foo"),
          "replace_all 应换掉文件里全部匹配: %s", r);
    free(r);
    r = call("edit_file",
             "{\"path\":\"dup.txt\",\"line\":7,\"old_string\":\"bar\",\"new_"
             "string\":\"x\","
             "\"replace_all\":true}",
             &err);
    CHECK(err == 1, "replace_all 也必须锚定在真实的一行上: %s", r);
    free(r);

    /* ---- edit_file: line 是集合型 ----
     * 集合是**搜索范围** (old_string 的起点落在其中任一行即可), 不是
     * "每行都改一次": 真改动的仍是唯一那一处.  */
    puts("edit_file: line 集合");
    r = call("write_file",
             "{\"path\":\"set.txt\",\"content\":\"aaa\\nbbb\\nccc\\nddd\\n\"}",
             &err);
    CHECK(err == 0, "写入 set.txt: %s", r);
    free(r);

    /* 数组写法: 起点落在集合里的哪一行都算命中; 回执要带上整个集合 */
    r = call("edit_file",
             "{\"path\":\"set.txt\",\"line\":[1,2],\"old_string\":\"aaa\","
             "\"new_string\":\"AAA\"}",
             &err);
    CHECK(err == 0, "集合圈住的替换应成功: %s", r);
    CHECK(strstr(r, "第 1、2 行") != NULL, "回执里应带上整个集合: %s", r);
    free(r);
    r = call("read_file", "{\"path\":\"set.txt\"}", &err);
    CHECK(strstr(r, "AAA") != NULL && !strstr(r, "aaa"), "替换应落盘: %s", r);
    free(r);

    /* old_string 跨行时, 把覆盖到的几行都填进集合——不必赌起点是第几行 */
    r = call(
        "edit_file",
        "{\"path\":\"set.txt\",\"line\":[2,3],\"old_string\":\"bbb\\nccc\","
        "\"new_string\":\"B\\nC\"}",
        &err);
    CHECK(err == 0, "跨行替换 (集合给两行)应成功: %s", r);
    free(r);
    r = call("read_file", "{\"path\":\"set.txt\"}", &err);
    CHECK(strstr(r, "B") && strstr(r, "C") && !strstr(r, "bbb"),
          "跨行替换应落盘: %s", r);
    free(r);

    /* 集合里有多处匹配 → 仍然拒绝 (集合不是"每行改一次"的授权) */
    r = call("write_file",
             "{\"path\":\"two.txt\",\"content\":\"foo\\nx\\nfoo\\n\"}", &err);
    CHECK(err == 0, "写入 two.txt: %s", r);
    free(r);
    r = call("edit_file",
             "{\"path\":\"two.txt\",\"line\":[1,3],\"old_string\":\"foo\","
             "\"new_string\":\"bar\"}",
             &err);
    CHECK(err == 1 && strstr(r, "第 1、3 行里有 2 处") != NULL,
          "集合里多处匹配应拒绝: %s", r);
    free(r);

    /* 重复的行号要去重: 不然同一处匹配会被数成两处 */
    r = call("write_file", "{\"path\":\"dup3.txt\",\"content\":\"foo\\n\"}",
             &err);
    CHECK(err == 0, "写入 dup3.txt: %s", r);
    free(r);
    r = call("edit_file",
             "{\"path\":\"dup3.txt\",\"line\":[1,1],\"old_string\":\"foo\","
             "\"new_string\":\"bar\"}",
             &err);
    CHECK(err == 0, "重复行号应去重, 而不是当成两处: %s", r);
    free(r);

    /* 集合里有一行越界 → 和单个行号时一样, 报出文件总行数 */
    r = call("edit_file",
             "{\"path\":\"set.txt\",\"line\":[1,99],\"old_string\":\"x\","
             "\"new_string\":\"y\"}",
             &err);
    CHECK(err == 1 && strstr(r, "只有 4 行") != NULL,
          "集合里的越界行号应报错并给出总行数: %s", r);
    free(r);

    /* 写法本身不对的三种: 空数组、非整数元素、一次给太多 */
    r = call("edit_file",
             "{\"path\":\"set.txt\",\"line\":[],\"old_string\":\"x\","
             "\"new_string\":\"y\"}",
             &err);
    CHECK(err == 1 && strstr(r, "空数组") != NULL, "空数组应报错: %s", r);
    CHECK(strstr(r, "省略") != NULL, "空数组的报错要提示可以整个省略 line: %s",
          r);
    free(r);

    r = call("edit_file",
             "{\"path\":\"set.txt\",\"line\":[1,1.5],\"old_string\":\"x\","
             "\"new_string\":\"y\"}",
             &err);
    CHECK(err == 1 && strstr(r, "第 2 个") != NULL,
          "非整数元素应报错并指出是第几个: %s", r);
    free(r);

    /* ---- 省略 line = 全文件替换所有匹配 ----
     * 这是 range 那样的集合参数该有的默认值: 不给范围就是不设范围.  */
    r = call("write_file",
             "{\"path\":\"all.txt\",\"content\":\"k\\nx\\nk\\n\"}", &err);
    CHECK(err == 0, "写入 all.txt: %s", r);
    free(r);
    r = call("edit_file",
             "{\"path\":\"all.txt\",\"old_string\":\"k\",\"new_string\":\"K\"}",
             &err);
    CHECK(err == 0, "省略 line 应做全文件替换: %s", r);
    CHECK(strstr(r, "全文件替换") != NULL && strstr(r, "2 处") != NULL,
          "回执要说清是全文件替换、换了几处: %s", r);
    free(r);
    r = call("read_file", "{\"path\":\"all.txt\"}", &err);
    CHECK(strstr(r, "K") != NULL && !strstr(r, "k"), "两处都该被换掉: %s", r);
    free(r);

    /* 省略 line 时文件里没有 old_string: 只说整个文件里没有 (没有"哪几行"可说)
     */
    r = call(
        "edit_file",
        "{\"path\":\"all.txt\",\"old_string\":\"zzz\",\"new_string\":\"y\"}",
        &err);
    CHECK(err == 1 && strstr(r, "整个文件里没有") != NULL,
          "该报整个文件里没有: %s", r);
    free(r);

    /* line 给错了类型 (不是"想全局"): 仍然当场报错, 并告诉它可以省略 */
    r = call("edit_file",
             "{\"path\":\"all.txt\",\"line\":\"1\",\"old_string\":\"K\","
             "\"new_string\":\"z\"}",
             &err);
    CHECK(err == 1 && strstr(r, "整数或整数数组") != NULL,
          "line 类型错应报错: %s", r);
    CHECK(strstr(r, "整个省略") != NULL, "报错要指出可以省略 line: %s", r);
    free(r);

    {
        /* 65 个行号: 超过一次能圈住的范围, 要明说 */
        char big[600];
        size_t o = (size_t)snprintf(big, sizeof big,
                                    "{\"path\":\"set.txt\",\"line\":[");
        for (int i = 1; i <= 65; i++)
            o += (size_t)snprintf(big + o, sizeof big - o, "%s%d",
                                  i > 1 ? "," : "", i);
        snprintf(big + o, sizeof big - o,
                 "],\"old_string\":\"x\",\"new_string\":\"y\"}");
        r = call("edit_file", big, &err);
        CHECK(err == 1 && strstr(r, "一次最多") != NULL, "行号过多应报错: %s",
              r);
        free(r);
    }

    /* ---- list_dir ---- */
    puts("list_dir");
    r = call("list_dir", "{\"path\":\".\"}", &err);
    CHECK(err == 0 && strstr(r, "sub/") != NULL, "应列出子目录: %s", r);
    free(r);

    r = call("list_dir", "{\"path\":\"nope\"}", &err);
    CHECK(err == 1, "不存在的目录应报错: %s", r);
    free(r);

    /* 这两个工具都已经删掉: 搜索交给模型自己用 run_command 里的真 grep,
     * 子代理 (spawn_subagent)整个功能也去掉了. 留着断言是为了钉住
     * "不要再冒出一个半吊子的替代品".  */
    r = call("grep", "{\"pattern\":\"x\",\"path\":\".\"}", &err);
    CHECK(err == 1 && strstr(r, "未知工具") != NULL, "不该再有 grep 工具: %s",
          r);
    free(r);
    r = call("spawn_subagent", "{}", &err);
    CHECK(err == 1 && strstr(r, "未知工具") != NULL, "不该再有子代理工具: %s",
          r);
    free(r);

    /* ---- 超大文件不能把内存吃干 ---- */
    puts("超大文件防护");
    {
        /* 稀疏文件, 创建几乎不耗时; 关键是客户端要在读之前就发现它太大.
         * 开头 16 KB 写成 'x': 这样它是"文本" (探测的前 8 KB 里没有 NUL),
         * 否则连 read_file 都会先被二进制检测拦掉 —— 这个用例就测不到
         * "分段读大文件"了.  */
        FILE *big = fopen("huge.txt", "wb");
        CHECK(big != NULL, "创建测试文件失败");
        if (big) {
            char head[16 * 1024];
            memset(head, 'x', sizeof head);
            fwrite(head, 1, sizeof head, big);
            fseek(big, 40L * 1024 * 1024, SEEK_SET);
            fputc('x', big);
            fclose(big);
        }
        r = call("edit_file",
                 "{\"path\":\"huge.txt\",\"line\":1,\"old_string\":\"x\",\"new_"
                 "string\":\"y\"}",
                 &err);
        CHECK(err == 1, "超大文件的 edit_file 应被拒绝: %.120s", r);
        CHECK(strstr(r, "上限") != NULL, "应说明是超上限: %.120s", r);
        free(r);

        /* read_file 是分段读的, 应当照常可用 */
        r = call("read_file", "{\"path\":\"huge.txt\",\"limit\":1}", &err);
        CHECK(err == 0, "分段读大文件应当可用: %.120s", r);
        free(r);
        unlink("huge.txt");
    }

    /* ---- 二进制文件: 所有处理文本的工具都必须拒绝 (而且要说明该用什么) ----
     */
    puts("二进制拒绝");
    {
        FILE *bf = fopen("bin.dat", "wb");
        CHECK(bf != NULL, "创建二进制测试文件失败");
        if (bf) {
            fwrite("PNG\0\1\2\3", 1, 8, bf);
            fclose(bf);
        }
    }

    r = call("read_file", "{\"path\":\"bin.dat\"}", &err);
    CHECK(err == 1, "read_file 读二进制应被拒绝: %s", r);
    CHECK(strstr(r, "二进制") != NULL && strstr(r, "第 4 字节") != NULL,
          "拒绝理由要指出 NUL 在哪一字节: %s", r);
    free(r);

    r = call("edit_file",
             "{\"path\":\"bin.dat\",\"line\":1,\"old_string\":\"PNG\",\"new_"
             "string\":\"JPG\"}",
             &err);
    CHECK(err == 1 && strstr(r, "二进制") != NULL,
          "edit_file 改二进制应被拒绝: %s", r);
    free(r);

    r = call("write_file", "{\"path\":\"bin.dat\",\"content\":\"text\"}", &err);
    CHECK(err == 1 && strstr(r, "二进制") != NULL,
          "write_file 覆盖二进制应被拒绝: %s", r);
    free(r);

    /* 被拒绝的三次都不能动到文件本身 —— 拒绝的意义就在这里 */
    {
        FILE *bf = fopen("bin.dat", "rb");
        char keep[16];
        memset(keep, 0, sizeof keep);
        size_t kn = bf ? fread(keep, 1, sizeof keep, bf) : 0;
        if (bf)
            fclose(bf);
        CHECK(kn == 8 && memcmp(keep, "PNG\0\1\2\3", 8) == 0,
              "被拒绝的读/写不能改动二进制文件的字节");
    }

    /* 确认提示里要能看出改的是哪一行 */
    r = call("write_file",
             "{\"path\":\"confirm.txt\",\"content\":\"aaa\\nbbb\\n\"}", &err);
    free(r);
    r = call("edit_file",
             "{\"path\":\"confirm.txt\",\"line\":2,\"old_string\":\"bbb\","
             "\"new_string\":\"ccc\"}",
             &err);
    CHECK(err == 0 && strstr(r, "第 2 行") != NULL, "回执带行号: %s", r);
    free(r);

    /* ---- 哪些工具会改动磁盘 (决定是否弹确认) ---- */
    puts("写操作分类");
    CHECK(tool_mutating("run_command") == 1,
          "run_command 会执行命令, 必须确认");
    CHECK(tool_mutating("write_file") == 1, "write_file 会写盘, 必须确认");
    CHECK(tool_mutating("edit_file") == 1, "edit_file 会改盘, 必须确认");
    CHECK(tool_mutating("read_file") == 0, "read_file 只读, 不该打扰");
    CHECK(tool_mutating("list_dir") == 0, "list_dir 只读, 不该打扰");
    /* read_image 会在 ligent 自己的目录里留备份 (副作用),
     * 但不改用户的任何东西 —— 它是"读", 不该每次都拦一道 */
    CHECK(tool_mutating("read_image") == 0,
          "read_image 不改用户的文件, 不该打扰");
    CHECK(tool_mutating("没有这个工具") == 0, "未知工具按只读处理");
    CHECK(tool_mutating(NULL) == 0, "空名字不应崩");

    /* ---- read_image: 只收真的能内联进去的图 ----
     *
     * 两条拒绝路径是新的: 格式不认识、体积超限. 它们都必须**不备份** ——
     * 一张交不出去的图, 留备份只会让 ligent.archive 变成垃圾场.  */
    puts("read_image: 本地就把不合格的图拦掉");
    {
        char btmp[] = "/tmp/ligent_tools_img_XXXXXX";
        char *bdir = mkdtemp(btmp);
        CHECK(bdir != NULL, "建备份临时目录失败");
        if (bdir) {
            image_set_bindir(bdir);
            image_pending_take(); /* 清干净, 以免上一段残留 */

            /* 1) 内容是文本、扩展名骗人 */
            FILE *f = fopen("notanimage.png", "wb");
            if (f) {
                fputs("这不是图片", f);
                fclose(f);
            }
            r = call("read_image", "{\"path\":\"notanimage.png\"}", &err);
            CHECK(err == 1 && strstr(r, "不认识") != NULL,
                  "非图片内容应被拒: %s", r);
            CHECK(strstr(r, "按文件内容判断") != NULL, "应说明是看内容判断的");
            free(r);

            /* 2) 体积超限: base64 后超过 IMAGE_MAX_B64.
             *    4/3 * 原始大小 = 编码后大小, 所以原始要 > 3/4 * 上限.  */
            size_t raw_needed = (size_t)(IMAGE_MAX_B64 / 4 * 3) + 4096;
            f = fopen("huge.png", "wb");
            if (f) {
                fwrite("\x89PNG\r\n\x1a\n", 1, 8, f);
                char *pad = xcalloc(1, 65536);
                size_t left = raw_needed - 8;
                while (left > 0) {
                    size_t chunk = left > 65536 ? 65536 : left;
                    if (fwrite(pad, 1, chunk, f) != chunk)
                        break;
                    left -= chunk;
                }
                free(pad);
                fclose(f);
            }
            r = call("read_image", "{\"path\":\"huge.png\"}", &err);
            CHECK(err == 1 && strstr(r, "太大") != NULL,
                  "超限的图应被当场拒掉: %.120s", r);
            CHECK(strstr(r, "内联上限") != NULL, "应说清上限是多少");
            free(r);

            /* 3) 合法的小图: 成功, 并且挂上待发附件 */
            f = fopen("ok.png", "wb");
            if (f) {
                fwrite("\x89PNG\r\n\x1a\n", 1, 8, f);
                fwrite("payload", 1, 7, f);
                fclose(f);
            }
            r = call("read_image", "{\"path\":\"ok.png\"}", &err);
            CHECK(err == 0 && strstr(r, "已读入图片") != NULL,
                  "合法图片应成功: %s", r);
            CHECK(strstr(r, "base64") != NULL, "应说明会以 base64 内联");
            free(r);

            JsonValue *att = image_pending_take();
            CHECK(att && json_array_size(att) == 1, "应挂上 1 个待发附件");
            if (att && json_array_size(att) == 1)
                CHECK(strcmp(json_get_string(json_array_get(att, 0), "type"),
                             "ligent_image") == 0,
                      "附件应是内部引用块");
            json_free(att);

            /* 只有成功那一张留了备份 —— 两条拒绝路径都不该留下东西 */
            char *ls =
                xasprintf("ls %s/ligent.archive/images/*.png | wc -l", bdir);
            FILE *p = popen(ls, "r");
            int cnt = -1;
            if (p) {
                if (fscanf(p, "%d", &cnt) != 1)
                    cnt = -1;
                pclose(p);
            }
            free(ls);
            CHECK(cnt == 1, "只该留 1 份备份 (成功那张), 实际 %d", cnt);

            image_set_bindir(".");
        }
    }

    /* ---- 超长单行: read_file 报出的行号必须与 edit_file 的口径一致 ----
     *
     * read_file 以前用 fgets + 固定 64 KB 缓冲, 一行比缓冲长时会被切成"多行"、
     * 每块各带一个行号. 于是模型按 read_file 看到的行号去 edit_file 改,
     * 要么改错 地方、要么报越界 —— 而它没有任何办法察觉. 工具描述和 README
     * 都写着 "read_file 打出来的行号可以直接喂给 edit_file 的 line",
     * 这里把它钉住.  */
    puts("超长单行的行号口径");
    {
        FILE *lf = fopen("longline.txt", "wb");
        for (int i = 0; i < 70000; i++)
            fputc('a', lf); /* 跨过 64 KB 那块缓冲 */
        fputc('\n', lf);
        fputs("second line\nthird line\n", lf);
        fclose(lf);

        r = call("read_file", "{\"path\":\"longline.txt\"}", &err);
        CHECK(err == 0, "读超长行文件失败: %s", r);
        CHECK(strstr(r, "     1\ta") != NULL, "第 1 行应以 a 开头:\n%.120s", r);
        CHECK(strstr(r, "     2\tsecond line") != NULL,
              "超长行之后的第 2 行应是 second line (它不能被算成好几行): "
              "\n%.200s",
              r);
        CHECK(strstr(r, "     3\tthird line") != NULL,
              "第 3 行应是 third line");
        CHECK(strstr(r, "     4\t") == NULL, "不应该出现第 4 行");
        free(r);

        /* 拿 read_file 报出的行号去 edit_file 改, 必须命中同一处 */
        r = call("edit_file",
                 "{\"path\":\"longline.txt\",\"line\":3,"
                 "\"old_string\":\"third line\",\"new_string\":\"THIRD LINE\"}",
                 &err);
        CHECK(err == 0, "用 read_file 的行号改第 3 行失败: %s", r);
        CHECK(strstr(r, "第 3 行替换 1 处") != NULL,
              "回执应说清改的是第 3 行: %s", r);
        free(r);
        char *after = read_entire_file("longline.txt", NULL);
        CHECK(after && strstr(after, "THIRD LINE") != NULL, "改动应落到文件里");
        free(after);

        /* 单行本身就超过输出上限: 必须说清"这一行只给了开头", 不能说成
         * "已截断, 从下一行继续" —— 那会让调用方以为拿到的是完整的行.  */
        FILE *hf = fopen("hugeline.txt", "wb");
        for (int i = 0; i < 200000; i++)
            fputc('b', hf);
        fputc('\n', hf);
        fputs("tail\n", hf);
        fclose(hf);
        r = call("read_file", "{\"path\":\"hugeline.txt\"}", &err);
        CHECK(strstr(r, "第 1 行本身就超过") != NULL,
              "应说清是这一行超过上限: %.160s", r);
        CHECK(strstr(r, "     2\t") == NULL, "不能把剩下的半个行伪装成第 2 行");
        free(r);
        remove("hugeline.txt");
        remove("longline.txt");
    }

    /* ---- 空目录: qsort 的第一个参数会拿到 NULL ---- */
    puts("list_dir 空目录");
    if (mkdir("emptydir", 0755) != 0) { /* 可能已存在 */
    }
    r = call("list_dir", "{\"path\":\"emptydir\"}", &err);
    CHECK(err == 0 && strstr(r, "0 个条目") != NULL,
          "空目录应报 0 个条目, 实际 %s", r);
    free(r);
    rmdir("emptydir");

    /* ---- 未知工具 ---- */
    r = call("no_such_tool", "{}", &err);
    CHECK(err == 1 && strstr(r, "未知工具") != NULL, "未知工具应报错: %s", r);
    free(r);

    /* ---- 输出截断 ---- */
    puts("output truncation");
    r = call("run_command",
             "{\"command\":\"head -c 300000 /dev/zero | tr '\\\\0' 'a'\"}",
             &err);
    CHECK(strlen(r) <= LIGENT_TOOL_OUTPUT_LIMIT + 200,
          "输出应被截断, 实际 %zu 字节", strlen(r));
    CHECK(strstr(r, "截断") != NULL, "应提示已截断");
    free(r);

    printf("\n%d 项检查, %d 项失败\n", checks, failures);
    return failures ? 1 : 0;
}