import { test, describe } from "node:test";
import assert from "node:assert/strict";
import { checkSource, unusedExemptions, type Exemption } from "../../scripts/check-boundaries";

const noExemptions: ReadonlyArray<Exemption> = [];

describe("boundary check", () => {
  test("flags as any", () => {
    const v = checkSource([{ path: "a.ts", text: "const x = y as any;" }], noExemptions);
    assert.equal(v.length, 1);
    assert.equal(v[0]?.rule, "as-any");
  });

  test("flags as any[]", () => {
    const v = checkSource([{ path: "a.ts", text: "const x = y as any[];" }], noExemptions);
    assert.equal(v.length, 1);
    assert.equal(v[0]?.rule, "as-any");
  });

  test("flags a ts-ignore", () => {
    const v = checkSource([{ path: "a.ts", text: "// @ts-ignore\nconst x = 1;" }], noExemptions);
    assert.equal(v.length, 1);
    assert.equal(v[0]?.rule, "ts-ignore");
  });

  test("flags ts-expect-error and ts-nocheck", () => {
    const expectError = checkSource([{ path: "a.ts", text: "// @ts-expect-error" }], noExemptions);
    const noCheck = checkSource([{ path: "a.ts", text: "// @ts-nocheck" }], noExemptions);
    assert.equal(expectError.length, 1);
    assert.equal(noCheck.length, 1);
  });

  test("flags a non-null assertion before a property access", () => {
    const v = checkSource([{ path: "a.ts", text: "const w = data.model!.width;" }], noExemptions);
    assert.equal(v.length, 1);
    assert.equal(v[0]?.rule, "non-null-assertion");
  });

  test("flags a non-null assertion with no property access after it", () => {
    const forms = ["const a = b!;", "f(g!);", "const c = arr[0]!;", "const d = [x!, y];", "const e = obj\n  .a!\n  .b;"];
    for (const text of forms) {
      const v = checkSource([{ path: "a.ts", text }], noExemptions);
      assert.equal(v.length, 1, text);
      assert.equal(v[0]?.rule, "non-null-assertion", text);
    }
  });

  test("does not flag strict inequality, spaced or unspaced", () => {
    for (const text of ["if (a !== b.c) return;", "if (a!==b.c) return;", "if (a != b.c) return;", "if (a!=b.c) return;"]) {
      assert.equal(checkSource([{ path: "a.ts", text }], noExemptions).length, 0, text);
    }
  });

  test("does not flag boolean negation", () => {
    for (const text of ["if (!ok.value) return;", "const n = a && !b.c;", "return !this.done;", "const m = [!x.y];"]) {
      assert.equal(checkSource([{ path: "a.ts", text }], noExemptions).length, 0, text);
    }
  });

  test("does not flag an exclamation mark in prose", () => {
    const text = 'description: "Done! Use browser_snapshot as the default. Options: any of these."';
    assert.equal(checkSource([{ path: "a.ts", text }], noExemptions).length, 0);
  });

  test("flags an inline object cast", () => {
    const v = checkSource([{ path: "a.ts", text: "const d = r.data as { sessionId: string };" }], noExemptions);
    assert.equal(v.length, 1);
    assert.equal(v[0]?.rule, "inline-object-cast");
  });

  test("flags a double cast", () => {
    const v = checkSource([{ path: "a.ts", text: "const d = r as unknown as Session;" }], noExemptions);
    assert.equal(v.some((x) => x.rule === "double-cast"), true);
  });

  test("allows as const", () => {
    assert.equal(checkSource([{ path: "a.ts", text: "const x = [1] as const;" }], noExemptions).length, 0);
  });

  test("flags a cast to a named type", () => {
    const v = checkSource([{ path: "a.ts", text: "return ok(raw as ResultOf<M>);" }], noExemptions);
    assert.equal(v.some((x) => x.rule === "named-cast"), true);
  });

  test("flags a cast to a function type", () => {
    const v = checkSource([{ path: "a.ts", text: "(fn as (a: unknown) => void)(x);" }], noExemptions);
    assert.equal(v.some((x) => x.rule === "function-cast"), true);
  });

  test("flags a cast whose target type sits on the next line", () => {
    const v = checkSource([{ path: "a.ts", text: "const f = base.constructor as\n  new () => void;" }], noExemptions);
    assert.equal(v.some((x) => x.rule === "trailing-cast"), true);
  });

  test("does not flag the word as inside prose", () => {
    const text = 'const d = "Capture the page as a JPEG. DO NOT use as a default tool.";';
    assert.equal(checkSource([{ path: "a.ts", text }], noExemptions).length, 0);
  });

  test("flags a tool reaching the session directly", () => {
    const forms = [
      "const r = await client.session().call(\"DOM.resolveNode\", { backendNodeId: id });",
      "const r = await client.session().callBrowser(\"Target.getTargets\");",
      "const r = await client.session().callOnTarget(\"Page.enable\", {}, sid);",
      "const r = await session.call(\"Accessibility.getFullAXTree\", {});",
      "const r = await session.callBrowser(\"Browser.getWindowForTarget\", { targetId });",
    ];
    for (const text of forms) {
      const v = checkSource([{ path: "src/domains/thing.ts", text }], noExemptions);
      assert.equal(v.some((x) => x.rule === "raw-cdp-call"), true, text);
    }
  });

  test("flags a tool calling evaluateJs directly", () => {
    const v = checkSource(
      [{ path: "src/domains/thing.ts", text: "const r = await client.evaluateJs(expr);" }],
      noExemptions,
    );
    assert.equal(v.some((x) => x.rule === "raw-evaluate"), true);
  });

  test("does not flag the session layer, which owns the session", () => {
    const text = 'const r = await session.callBrowser("Target.getTargets");\nawait client.evaluateJs(expr);';
    for (const path of ["src/client.ts", "src/cdp/session.ts", "src/cdp/target-factory.ts"]) {
      assert.equal(checkSource([{ path, text }], noExemptions).length, 0, path);
    }
  });

  test("does not mistake Function.prototype.call in an evaluated snippet for a CDP call", () => {
    const text = "const expr = `${prelude} ${opts.fnBody} }).call(el, __arg); })()`;";
    assert.equal(checkSource([{ path: "src/domains/form.ts", text }], noExemptions).length, 0);
  });

  test("reports the 1-indexed line number and the trimmed text", () => {
    const v = checkSource([{ path: "a.ts", text: "const a = 1;\n  const b = c as any;" }], noExemptions);
    assert.equal(v[0]?.line, 2);
    assert.equal(v[0]?.text, "const b = c as any;");
    assert.equal(v[0]?.path, "a.ts");
  });

  test("scans every file it is given", () => {
    const v = checkSource(
      [
        { path: "a.ts", text: "const x = y as any;" },
        { path: "b.ts", text: "const z = w as any;" },
      ],
      noExemptions,
    );
    assert.deepEqual(
      v.map((x) => x.path),
      ["a.ts", "b.ts"],
    );
  });
});

describe("boundary check exemptions", () => {
  const exemptions: ReadonlyArray<Exemption> = [
    { path: "a.ts", rule: "inline-object-cast", count: 1, reason: "narrows an untyped dynamic import" },
  ];

  test("permits up to count violations for the exempted path and rule", () => {
    const v = checkSource([{ path: "a.ts", text: "const m = mod as { default?: unknown };" }], exemptions);
    assert.equal(v.length, 0);
  });

  test("reports the count+1-th violation so new casts cannot hide behind an exemption", () => {
    const text = "const m = mod as { default?: unknown };\nconst n = other as { x?: unknown };";
    const v = checkSource([{ path: "a.ts", text }], exemptions);
    assert.equal(v.length, 1);
    assert.equal(v[0]?.line, 2);
    assert.equal(v[0]?.rule, "inline-object-cast");
  });

  test("does not exempt a different rule in the same file", () => {
    const v = checkSource([{ path: "a.ts", text: "const x = y as any;" }], exemptions);
    assert.equal(v.length, 1);
    assert.equal(v[0]?.rule, "as-any");
  });

  test("does not exempt the same rule in a different file", () => {
    const v = checkSource([{ path: "b.ts", text: "const m = mod as { default?: unknown };" }], exemptions);
    assert.equal(v.length, 1);
    assert.equal(v[0]?.path, "b.ts");
  });

  test("counts exempted violations per file, not across all files", () => {
    const wide: ReadonlyArray<Exemption> = [
      { path: "a.ts", rule: "as-any", count: 1, reason: "one" },
      { path: "b.ts", rule: "as-any", count: 1, reason: "two" },
    ];
    const v = checkSource(
      [
        { path: "a.ts", text: "const x = y as any;" },
        { path: "b.ts", text: "const z = w as any;" },
      ],
      wide,
    );
    assert.equal(v.length, 0);
  });

  test("normalises windows path separators before matching", () => {
    const v = checkSource([{ path: "src\\util\\a.ts", text: "const x = y as any;" }], [
      { path: "src/util/a.ts", rule: "as-any", count: 1, reason: "platform independent" },
    ]);
    assert.equal(v.length, 0);
  });

  test("unusedExemptions names exemptions no longer earning their keep", () => {
    const stale = unusedExemptions([{ path: "a.ts", text: "const x = 1;" }], exemptions);
    assert.deepEqual(
      stale.map((e) => e.rule),
      ["inline-object-cast"],
    );
  });

  test("unusedExemptions is empty when every exemption is consumed", () => {
    const used = unusedExemptions([{ path: "a.ts", text: "const m = mod as { default?: unknown };" }], exemptions);
    assert.deepEqual(used, []);
  });
});