import { test, after } from "node:test";
import assert from "node:assert/strict";
import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
import os from "node:os";
import path from "node:path";
import { SourceRefusal } from "./sourceAudit";
import { escapeHtml, hrefFor, renderTreeIndex, sortEntries, writeTreeIndexes } from "./sourceTree";

// Run with:
//   pnpm --filter yt-dlp-transcript-common test
//
// The raw tree's directory pages (sourceTree.ts): hrefs a static host can
// resolve for the repo's real bracketed names, escaped labels, the order,
// the relative breadcrumbs, and the refusals.

const TMP = mkdtempSync(path.join(os.tmpdir(), "source-tree-"));
after(() => rmSync(TMP, { recursive: true, force: true }));

const META = { mirrorHead: "0123456789abcdef0123456789abcdef01234567", generatedAt: "2026-09-28T12:00:00.000Z" };

test("hrefs are URL-encoded, a directory's with a trailing slash — the repo's brackets included", () => {
  assert.equal(hrefFor({ name: "[slug]", dir: true }), "%5Bslug%5D/");
  assert.equal(hrefFor({ name: "Archivo[wdth,wght].ttf", dir: false }), "Archivo%5Bwdth%2Cwght%5D.ttf");
  assert.equal(hrefFor({ name: "a b#c?.md", dir: false }), "a%20b%23c%3F.md");
  assert.equal(hrefFor({ name: "page.tsx", dir: false }), "page.tsx");
});

test("names are escaped wherever they are printed", () => {
  assert.equal(escapeHtml(`<a href="x">&'</a>`), "&lt;a href=&quot;x&quot;&gt;&amp;&#39;&lt;/a&gt;");
  const html = renderTreeIndex({
    relDir: "x",
    entries: [{ name: "<script>.ts", dir: false, bytes: 3 }],
    ...META,
  });
  assert.ok(!html.includes("<script>.ts"), "a name never becomes markup");
  assert.match(html, /href="%3Cscript%3E\.ts">&lt;script&gt;\.ts<\/a>/);
});

test("directories first, then files, each by name; sizes with raw bytes in the title", () => {
  const sorted = sortEntries([
    { name: "b.ts", dir: false, bytes: 1 },
    { name: "z", dir: true, bytes: 0 },
    { name: "a.ts", dir: false, bytes: 2048 },
    { name: "B", dir: true, bytes: 0 },
  ]);
  assert.deepEqual(sorted.map((e) => e.name), ["B", "z", "a.ts", "b.ts"]);
  const html = renderTreeIndex({ relDir: "", entries: sorted, ...META });
  assert.match(html, /<span title="2048 bytes">2\.0 KB<\/span>/);
  assert.match(html, /<meta name="robots" content="noindex">/);
  assert.match(html, /main @ 0123456789ab · generated 2026-09-28T12:00:00\.000Z · <a href="\/source\/">clone<\/a>/);
});

test("breadcrumbs hop up relatively; the root has no `..` row", () => {
  const root = renderTreeIndex({ relDir: "", entries: [], ...META });
  assert.ok(!root.includes(`href="../"`));
  assert.match(root, /<nav><strong>archilyzer<\/strong><\/nav>/);
  const deep = renderTreeIndex({ relDir: "homepage/app/[slug]", entries: [], ...META });
  assert.match(
    deep,
    /<nav><a href="\.\.\/\.\.\/\.\.\/">archilyzer<\/a><span class="sep">\/<\/span><a href="\.\.\/\.\.\/">homepage<\/a><span class="sep">\/<\/span><a href="\.\.\/">app<\/a><span class="sep">\/<\/span><strong>\[slug\]<\/strong><\/nav>/,
  );
  assert.match(deep, /<tr><td class="name"><a href="\.\.\/">\.\.<\/a>/);
});

test("writeTreeIndexes pages every directory and counts the tree, refusing a tracked index.html, a 404.html or a symlink", async () => {
  const tree = path.join(TMP, "t1");
  mkdirSync(path.join(tree, "app", "[slug]"), { recursive: true });
  writeFileSync(path.join(tree, "README.md"), "hello\n");
  writeFileSync(path.join(tree, "app", "[slug]", "page.tsx"), "x");
  const totals = await writeTreeIndexes(tree, META);
  assert.deepEqual(totals, { files: 2, dirs: 3, bytes: 7 });
  for (const d of ["", "app", "app/[slug]"]) assert.ok(existsSync(path.join(tree, d, "index.html")), d);
  const appPage = readFileSync(path.join(tree, "app", "index.html"), "utf8");
  assert.match(appPage, /href="%5Bslug%5D\/">\[slug\]\/<\/a>/);
  assert.ok(!appPage.includes(`>index.html<`), "a page does not list itself");

  const withIndex = path.join(TMP, "t2");
  mkdirSync(path.join(withIndex, "docs"), { recursive: true });
  writeFileSync(path.join(withIndex, "docs", "index.html"), "<p>tracked</p>");
  await assert.rejects(writeTreeIndexes(withIndex, META), (e) => e instanceof SourceRefusal && /docs\/index\.html/.test(e.message));

  // A tracked 404.html anywhere: Pages would serve it, as HTML on this
  // origin, for every missing path below its directory.
  const with404 = path.join(TMP, "t4");
  mkdirSync(path.join(with404, "docs", "deep"), { recursive: true });
  writeFileSync(path.join(with404, "docs", "deep", "404.html"), "<script>x</script>");
  await assert.rejects(
    writeTreeIndexes(with404, META),
    (e) => e instanceof SourceRefusal && /docs\/deep\/404\.html; Pages would serve it, as HTML/.test(e.message),
  );

  const withLink = path.join(TMP, "t3");
  mkdirSync(withLink);
  symlinkSync("/etc/hostname", path.join(withLink, "leak"));
  await assert.rejects(writeTreeIndexes(withLink, META), (e) => e instanceof SourceRefusal && /symlink/.test(e.message));
});