import { test } from "node:test";
import assert from "node:assert/strict";
import { readFile } from "node:fs/promises";
import { createHash } from "node:crypto";
import catalog from "../src/components/canvas/icon-catalog-data.json" with { type: "json" };
import manifest from "../src/lib/canvas-icon-assets.json" with { type: "json" };
import { iconAsset, validateIconShard } from "../src/lib/canvas-icon-loader.ts";
import { decodeCanvas, emptyCanvas, makeCanvasNode } from "../src/lib/canvas.ts";
import { createResourceLoader } from "../src/lib/resource-loader.ts";

test("all Lucide and experimental Tabler IDs map to valid local shards and survive snapshots", async () => {
  assert.equal(catalog.filter((icon) => icon.source === "lucide").length, 2313);
  assert.equal(catalog.filter((icon) => icon.source === "tabler").length, 24);
  assert.equal(new Set(catalog.map((icon) => icon.name)).size, catalog.length);
  const loaded = new Map();
  for (const asset of Object.values(manifest.assets)) {
    const content = await readFile(`public${manifest.root}/${asset}`, "utf8");
    assert.ok(asset.includes(createHash("sha256").update(content.trimEnd()).digest("hex").slice(0, 12)));
    loaded.set(`${manifest.root}/${asset}`, validateIconShard(JSON.parse(content)));
    assert.ok(Buffer.byteLength(content) < 20_000, asset);
  }
  for (const icon of catalog) {
    assert.ok(loaded.get(iconAsset(icon.name))[icon.name]);
    assert.ok(icon.categories.every((category) => ["arrows", "people", "office", "media", "tech", "business", "nature", "travel", "shapes"].includes(category)));
  }
  for (const name of ["Star", "TablerAlien", "TablerCube3dSphere"]) {
    assert.ok(catalog.some((icon) => icon.name === name));
    const node = makeCanvasNode("icon", { x: 0, y: 0 }); node.data.icon = name;
    assert.equal(decodeCanvas(JSON.stringify({ ...emptyCanvas(), nodes: [node] })).nodes[0].data.icon, name);
  }
});

test("icon data rejects executable shapes, events and external paint references", () => {
  for (const node of [["script", {}], ["path", { onload: "alert(1)" }], ["path", { fill: "url(https://example.com)" }], ["use", { href: "bad" }]]) {
    assert.throws(() => validateIconShard({ Star: [node] }));
  }
});

const tick = () => new Promise((resolve) => setImmediate(resolve));
test("an immediately unmounted icon does not start a network request", async () => {
  let calls = 0;
  const loader = createResourceLoader(async () => { calls++; return "unused"; });
  const controller = new AbortController();
  const pending = loader.request("unused", controller.signal);
  const rejected = assert.rejects(pending, { name: "AbortError" });
  controller.abort(); await rejected; await tick();
  assert.equal(calls, 0); assert.equal(loader.peek("unused"), undefined);
});

test("loader bounds concurrency, deduplicates shared shards and reuses cache", async () => {
  let active = 0, peak = 0, calls = 0;
  const finish = [];
  const loader = createResourceLoader(async (key) => {
    active++; peak = Math.max(peak, active); calls++;
    await new Promise((resolve) => finish.push(resolve)); active--; return key;
  }, 2, 3);
  const a = loader.request("a"), duplicate = loader.request("a"), b = loader.request("b"), c = loader.request("c");
  await tick(); assert.equal(calls, 2);
  finish.splice(0).forEach((resolve) => resolve()); await tick();
  assert.equal(calls, 3); finish.splice(0).forEach((resolve) => resolve());
  assert.deepEqual(await Promise.all([a, duplicate, b, c]), ["a", "a", "b", "c"]);
  assert.equal(await loader.request("a"), "a"); assert.equal(calls, 3); assert.equal(peak, 2);
});

test("unused queued loads never start; a remaining subscriber keeps a shared load alive", async () => {
  const seen = []; let release;
  const loader = createResourceLoader(async (key) => { seen.push(key); if (key === "a") await new Promise((resolve) => release = resolve); return key; }, 1);
  const first = new AbortController(), queued = new AbortController();
  const a = loader.request("a", first.signal), shared = loader.request("a");
  const b = loader.request("b", queued.signal);
  const rejected = Promise.all([assert.rejects(a, { name: "AbortError" }), assert.rejects(b, { name: "AbortError" })]);
  await tick(); first.abort(); queued.abort(); release();
  await rejected; assert.equal(await shared, "a"); await tick(); assert.deepEqual(seen, ["a"]);
});

test("active aborts and failed requests can retry; least recently used cache is bounded", async () => {
  let fail = true;
  const loader = createResourceLoader(async (key, signal) => {
    if (key === "abort") return new Promise((_, reject) => signal.addEventListener("abort", () => reject(new DOMException("Aborted", "AbortError")), { once: true }));
    if (key === "fail" && fail) { fail = false; throw new Error("offline"); } return key;
  }, 1, 2);
  const controller = new AbortController(); const pending = loader.request("abort", controller.signal);
  const rejected = assert.rejects(pending, { name: "AbortError" }); await tick(); controller.abort(); await rejected; await tick();
  await assert.rejects(loader.request("fail"), /offline/); await tick(); assert.equal(await loader.request("fail"), "fail");
  await loader.request("a"); await loader.request("b");
  assert.equal(loader.peek("fail"), undefined); assert.equal(loader.peek("a"), "a");
});