import assert from "node:assert/strict";
import { join } from "node:path";
import { DatabaseSync } from "node:sqlite";
import { test } from "node:test";
import { Ledger, type LedgerRecord } from "../src/ledger/index.ts";
import { hash } from "../src/vocab/index.ts";
import {
  callStart,
  closeStage,
  exited,
  freshLedger,
  implementation,
  notStarted,
  openStage,
  planRun,
  proposal,
  range,
  tempDir,
} from "./ledger-helpers.ts";

// 预期值照 docs/结构.md 第四部分"账本记录"、方法.md 第七部分"什么时候扣次数"和第九部分的文字写：
// 整张表禁改禁删；按定义只发生一次的记录重复就报错，其余照写；事务要么全写要么全不写；
// 关掉再打开读出不变；表结构版本不对打开报错。

function countRows(path: string): number {
  const db = new DatabaseSync(path);
  const n = Number((db.prepare("SELECT count(*) AS n FROM records").get() as { n: number }).n);
  db.close();
  return n;
}

test("触发器：直接用 SQL 执行 UPDATE、DELETE 都被拒绝，记录不变", (t) => {
  const { ledger, path } = freshLedger(t);
  ledger.append("config", { n: 2 });
  const before = ledger.records();
  const db = new DatabaseSync(path);
  t.after(() => db.close());
  assert.throws(() => db.exec("UPDATE records SET content = '{\"n\":3}'"), /禁止修改/);
  assert.throws(() => db.exec("UPDATE records SET hash = 'x' WHERE seq = 1"), /禁止修改/);
  assert.throws(() => db.exec("DELETE FROM records"), /禁止删除/);
  assert.throws(() => db.exec("DELETE FROM records WHERE seq = 1"), /禁止删除/);
  assert.deepEqual(ledger.records(), before);
});

// 唯一约束（schema.ts）：有自己编号、按定义只发生一次的记录，同一个编号写第二条就报错，内容完全相同也报错，
// 不多写一条；别的编号照常写。

test("唯一约束：同一个阶段开两次报错", (t) => {
  const { ledger, path } = freshLedger(t);
  openStage(ledger, "s1", "proposal", 1);
  assert.throws(() => openStage(ledger, "s1", "proposal", 1), /stage_open_once/);
  openStage(ledger, "s2", "proposal", 1);
  assert.equal(countRows(path), 2);
});

test("唯一约束：同一个阶段关两次报错", (t) => {
  const { ledger, path } = freshLedger(t);
  openStage(ledger, "s1", "proposal", 1);
  closeStage(ledger, "s1");
  assert.throws(() => closeStage(ledger, "s1"), /stage_close_once/);
  assert.equal(countRows(path), 2);
});

test("唯一约束：同一次运行登记两次报错", (t) => {
  const { ledger, path } = freshLedger(t);
  planRun(ledger, "run1", "forward", 1);
  assert.throws(() => planRun(ledger, "run1", "forward", 1), /run_planned_once/);
  planRun(ledger, "run2", "forward", 1);
  assert.equal(countRows(path), 2);
});

test("唯一约束：同一次运行确认启动两次报错", (t) => {
  const { ledger, path } = freshLedger(t);
  planRun(ledger, "run1", "forward", 1);
  ledger.append("runStarted", { run: "run1" });
  assert.throws(() => ledger.append("runStarted", { run: "run1" }), /run_started_or_not_started_once/);
  assert.equal(countRows(path), 2);
});

test("唯一约束：确认启动和\"结果是没启动\"算同一条，一次运行只能有一样，两种先后都报错", (t) => {
  // 登记→确认启动→结果没启动、登记→结果没启动→确认启动，第三步都报错：一次运行不能既扣次又退还（方法.md 第七部分）。
  const { ledger, path } = freshLedger(t);
  planRun(ledger, "run1", "forward", 1);
  ledger.append("runStarted", { run: "run1" });
  assert.throws(() => ledger.append("runResult", { run: "run1", process: notStarted, judged: null }), /run_started_or_not_started_once/);
  planRun(ledger, "run2", "forward", 1);
  ledger.append("runResult", { run: "run2", process: notStarted, judged: null });
  assert.throws(() => ledger.append("runStarted", { run: "run2" }), /run_started_or_not_started_once/);
  // 正常情况：确认启动后写启动过的结果。
  ledger.append("runResult", { run: "run1", process: exited, judged: null });
  assert.equal(countRows(path), 5); // 两条登记、一条确认启动、两条结果
});

test("唯一约束：同一次运行写两个结果报错", (t) => {
  const { ledger, path } = freshLedger(t);
  planRun(ledger, "run1", "forward", 1);
  ledger.append("runStarted", { run: "run1" });
  ledger.append("runResult", { run: "run1", process: exited, judged: null });
  assert.throws(() => ledger.append("runResult", { run: "run1", process: exited, judged: null }), /run_result_once/);
  assert.equal(countRows(path), 3);
});

test("唯一约束：同一次模型调用开始两次报错", (t) => {
  const { ledger, path } = freshLedger(t);
  ledger.append("callStarted", callStart("k1"));
  assert.throws(() => ledger.append("callStarted", callStart("k1")), /call_started_once/);
  ledger.append("callStarted", callStart("k2"));
  assert.equal(countRows(path), 2);
});

test("唯一约束：同一次模型调用结束两次报错", (t) => {
  const { ledger, path } = freshLedger(t);
  ledger.append("callStarted", callStart("k1"));
  ledger.append("callEnded", { call: "k1", ending: "completed" });
  assert.throws(() => ledger.append("callEnded", { call: "k1", ending: "failed", reason: "又报了一次" }), /call_ended_once/);
  assert.equal(countRows(path), 2);
});

test("唯一约束：同一轮结算两次报错，不同轮各一次照写；结算不带消融编号", (t) => {
  // 每轮最多采纳一个改法，所以最多一次消融（docs/结构.md 第四部分）：结算按轮次只发生一次。
  const { ledger, path } = freshLedger(t);
  ledger.append("settlement", { round: 1, result: { cells: { p1: "valid" } } });
  assert.throws(() => ledger.append("settlement", { round: 1, result: { cells: { p1: "insufficient" } } }), /settlement_once/);
  ledger.append("settlement", { round: 2, result: { cells: { p1: "insufficient" } } });
  ledger.append("settlement", { round: 3, result: { cells: { p1: "valid" } } });
  assert.throws(() => ledger.append("settlement", { ablation: "a1", result: {} } as never), /settlement/);
  assert.throws(() => ledger.append("settlement", { round: 4, ablation: "a4", result: {} } as never), /settlement/);
  assert.equal(countRows(path), 3);
});

test("私人笔记：同一人写两条都存下，以后写的（序号大的）为准；笔记不带版本号", (t) => {
  // 笔记不属于任何阶段，以最后写入的一条为准，序号就是先后（docs/结构.md 第四部分）。
  // 后写的正文按字典序排在前面，中间夹着别人的笔记：取"序号最大的那条"才得到后写的。
  const { ledger, path } = freshLedger(t);
  ledger.append("note", { author: "r1", body: "z 先写的" });
  ledger.append("note", { author: "r2", body: "别人的笔记" });
  ledger.append("note", { author: "r1", body: "a 后写的" });
  const mine = ledger
    .records()
    .filter((r): r is LedgerRecord<"note"> => r.kind === "note")
    .filter((r) => r.content.author === "r1");
  assert.deepEqual(mine.map((r) => [r.seq, r.content.body]), [[1, "z 先写的"], [3, "a 后写的"]]);
  assert.equal(mine.at(-1)!.content.body, "a 后写的");
  assert.throws(() => ledger.append("note", { author: "r1", version: 2, body: "带版本号" } as never), /note/);
  assert.equal(countRows(path), 3);
});

test("没有唯一约束的记录照写：同样的事件、决定写两次就是两条", (t) => {
  const { ledger, path } = freshLedger(t);
  const e = { event: "untested", reason: "剩余次数不够", objects: ["cell3"] };
  const first = ledger.append("event", e);
  const second = ledger.append("event", e);
  assert.equal(second.seq, first.seq + 1);
  const d = { decision: "batch", round: 1, rule: "bestExpected", ruleVersion: 1, params: {}, seed: null, input: { x: 1 }, output: ["c1"] };
  ledger.append("decision", d);
  ledger.append("decision", d);
  assert.equal(countRows(path), 4);
});

test("内容不符合定义时不写入：多出的字段、提交内容不合格、提交编号 item 和提交种类对不上", (t) => {
  const { ledger, path } = freshLedger(t);
  openStage(ledger, "s1", "wrapUp", 1);
  assert.throws(() => ledger.append("runStarted", { run: "r1", extra: 1 } as never), /runStarted/);
  assert.throws(
    () => ledger.append("submission", { stageId: "s1", author: "r1", target: null, item: null, version: 1, kind: "wrapUp", content: { body: "" } }),
    /wrapUp/,
  );
  // 提案、挑刺一人能交好几份，必须带编号；实现一人对一个候选只交一份，编号必须为空，
  // 否则另起一个编号就能绕开"实现不能替换"。
  openStage(ledger, "prop", "proposal", 1);
  assert.throws(
    () => ledger.append("submission", { stageId: "prop", author: "r1", target: null, item: null as never, version: 1, kind: "proposal", content: proposal(range(1, 2, 3)) }),
    /proposal/,
  );
  openStage(ledger, "impl", "implementation", 1, ["e1"]);
  assert.throws(
    () => ledger.append("submission", { stageId: "impl", author: "e1", target: "c1", item: "x" as never, version: 1, kind: "implementation", content: implementation() }),
    /implementation/,
  );
  assert.equal(countRows(path), 3); // 三条开阶段
});

test("写提案：作者自评拆成一条封存，提案记录里不带它", (t) => {
  const { ledger } = freshLedger(t);
  openStage(ledger, "s1", "proposal", 1);
  const record = ledger.append("submission", {
    stageId: "s1", author: "r1", target: null, item: "r1-1", version: 1, kind: "proposal", content: proposal(range(1, 2, 3)),
  });
  const all = ledger.records();
  const stored = all.find((r) => r.kind === "submission")!;
  assert.equal(JSON.stringify(stored.content).includes("authorEstimate"), false);
  assert.equal(JSON.stringify(record.content).includes("authorEstimate"), false);
  const { authorEstimate: _, ...withoutEstimate } = proposal(range(1, 2, 3));
  assert.deepEqual(stored.content.content, withoutEstimate);
  const seal = all.find((r) => r.kind === "seal")!;
  assert.deepEqual(seal.content, { proposal: record.seq, range: range(1, 2, 3) });
  assert.equal(seal.seq, record.seq + 1);
});

test("退回：被退回的内容原样存，带退回理由；来自 Jev 的带原始概率和结论", (t) => {
  const { ledger } = freshLedger(t);
  const malformed = { factors: "不是数组" };
  ledger.append("rejection", { stageId: "s1", author: "r1", kind: "proposal", submitted: malformed, reason: "因子清单格式不对", jev: null });
  ledger.append("rejection", {
    stageId: "s6", author: "r2", kind: "response", submitted: { body: "改了评测" }, reason: "冻结条款改动了评测",
    jev: { probabilities: { yes: 0.97, no: 0.03 }, conclusion: "changesEvaluation" },
  });
  const rejections = ledger.records().filter((r) => r.kind === "rejection");
  assert.deepEqual(rejections.map((r) => r.content.submitted), [malformed, { body: "改了评测" }]);
  assert.deepEqual(rejections[1]!.content.jev, { probabilities: { yes: 0.97, no: 0.03 }, conclusion: "changesEvaluation" });
});

test("事务：中途出错，一条都没写进去；中途被拒收，前面写的也撤销；正常结束则全部写进去", (t) => {
  const { ledger, path } = freshLedger(t);
  assert.throws(
    () =>
      ledger.transaction(() => {
        planRun(ledger, "run1", "forward", 1);
        ledger.append("runStarted", { run: "run1" });
        throw new Error("算到一半出错");
      }),
    /算到一半出错/,
  );
  assert.equal(countRows(path), 0);
  assert.throws(
    () =>
      ledger.transaction(() => {
        planRun(ledger, "run9", "forward", 1);
        ledger.append("runResult", { run: "run9", process: exited, judged: null });
      }),
    /确认启动/,
  );
  assert.equal(countRows(path), 0);
  ledger.transaction(() => {
    planRun(ledger, "run1", "forward", 1);
    ledger.append("runStarted", { run: "run1" });
  });
  assert.equal(countRows(path), 2);
});

test("事务：异步函数被类型检查挡住", () => {
  // 只给 npm run check 看，不执行：await 之后的写入发生在事务提交之后，回滚管不到。
  const typeOnly = (ledger: Ledger) =>
    // @ts-expect-error 事务函数的返回值类型排除了 Promise。
    ledger.transaction(async () => {
      ledger.append("config", { n: 1 });
    });
  assert.equal(typeof typeOnly, "function");
});

test("关掉再打开：读出的记录不变，序号接着往下排", (t) => {
  const path = join(tempDir(t), "ledger.db");
  const ledger = Ledger.open(path);
  ledger.append("config", { researchers: ["r1", "r2"] });
  openStage(ledger, "s1", "proposal", 1);
  ledger.append("submission", { stageId: "s1", author: "r1", target: null, item: "r1-1", version: 1, kind: "proposal", content: proposal(range(1, 2, 3)) });
  ledger.append("note", { author: "r2", body: "笔记" });
  closeStage(ledger, "s1");
  planRun(ledger, "run1", "forward", 1);
  ledger.append("callStarted", callStart("k1"));
  const before = ledger.records();
  ledger.close();
  const reopened = Ledger.open(path);
  t.after(() => reopened.close());
  assert.deepEqual(reopened.records(), before);
  assert.equal(before.length, 8); // 配置、开阶段、提案、封存、笔记、关阶段、登记运行、调用开始
  assert.deepEqual(before.map((r) => r.hash), before.map((r) => hash(r.content)));
  assert.equal(reopened.append("runStarted", { run: "run1" }).seq, 9);
});

test("打开：表结构版本不对报错；不是空文件也不是账本的库报错", (t) => {
  const dir = tempDir(t);
  const wrongVersion = join(dir, "v99.db");
  const db = new DatabaseSync(wrongVersion);
  db.exec("PRAGMA user_version = 99");
  db.close();
  assert.throws(() => Ledger.open(wrongVersion), /版本是 99/);

  const foreign = join(dir, "foreign.db");
  const other = new DatabaseSync(foreign);
  other.exec("CREATE TABLE t (x INTEGER)");
  other.close();
  assert.throws(() => Ledger.open(foreign), /版本是 0/);
});

test("打开：不是账本的库报错后，那个库的 journal_mode 不变", (t) => {
  const foreign = join(tempDir(t), "foreign.db");
  const other = new DatabaseSync(foreign);
  other.exec("CREATE TABLE t (x INTEGER)");
  const modeOf = (db: DatabaseSync) => (db.prepare("PRAGMA journal_mode").get() as { journal_mode: string }).journal_mode;
  const before = modeOf(other);
  other.close();
  assert.notEqual(before, "wal");
  assert.throws(() => Ledger.open(foreign), /版本是 0/);
  const reopened = new DatabaseSync(foreign);
  t.after(() => reopened.close());
  assert.equal(modeOf(reopened), before);
});

test("读出时按种类检查内容：绕过 ledger 插进去的坏记录，读取时报错", (t) => {
  const { ledger, path } = freshLedger(t);
  const db = new DatabaseSync(path);
  t.after(() => db.close());
  db.exec(`INSERT INTO records (kind, content, hash) VALUES ('runStarted', '{"run":"run1","x":1}', 'h')`);
  assert.throws(() => ledger.records(), /runStarted/);
});

test("查询：阶段关了没有、某份提交的最新一版（同一人对同一候选的另一份挑刺不算这一份的版本）", (t) => {
  const { ledger } = freshLedger(t);
  openStage(ledger, "s1", "critique", 1);
  assert.equal(ledger.stageClosed("s1"), false);
  const slot = { stageId: "s1", author: "r1", kind: "critique" as const, target: "c1", item: "k1" };
  assert.equal(ledger.latestSubmission(slot), undefined);
  ledger.append("submission", { ...slot, version: 1, content: { target: "whole", body: "第一版" } });
  const v2 = ledger.append("submission", { ...slot, version: 2, content: { target: "whole", body: "第二版" } });
  ledger.append("submission", { ...slot, item: "k2", version: 1, content: { target: "p1", body: "另一份" } });
  assert.deepEqual(ledger.latestSubmission(slot), v2);
  closeStage(ledger, "s1");
  assert.equal(ledger.stageClosed("s1"), true);
});