import { createHash } from "node:crypto";
import { lstat, mkdir, readFile, readdir, writeFile } from "node:fs/promises";
import { dirname, extname, resolve } from "node:path";

// Only these authored inputs are public. Build output, private deployment state,
// hidden files, dependencies, and symlinks are never traversed.
const textRoots = ["src", "scripts", "tests"];
const textExtensions = new Set([
  ".html",
  ".css",
  ".js",
  ".mjs",
  ".json",
  ".md",
]);
const assetExtensions = new Set([
  ".svg",
  ".png",
  ".jpg",
  ".jpeg",
  ".webp",
  ".avif",
  ".woff",
  ".woff2",
  ".mp4",
  ".webm",
]);
const documents = [
  ".vercelignore",
  "package.json",
  "package-lock.json",
  "vercel.json",
  "README.md",
  "ASSETS.md",
  "MOTION.md",
  "CAPTURES.md",
  "CONCEPT-MAP.md",
  "DEPLOYMENT.md",
];
const excludedDirectories = new Set([
  "node_modules",
  "dist",
  "reports",
  "captures",
]);

function escapeHtml(value) {
  return value.replace(
    /[&<>"']/g,
    (character) =>
      ({
        "&": "&amp;",
        "<": "&lt;",
        ">": "&gt;",
        '"': "&quot;",
        "'": "&#39;",
      })[character],
  );
}

async function listFiles(root, directory, extensions) {
  let entries;
  try {
    if (!(await lstat(resolve(root, directory))).isDirectory()) return [];
    entries = await readdir(resolve(root, directory), { withFileTypes: true });
  } catch (error) {
    if (error.code === "ENOENT") return [];
    throw error;
  }
  const paths = await Promise.all(
    entries.map(async (entry) => {
      if (entry.name.startsWith(".") || entry.isSymbolicLink()) return [];
      const path = `${directory}/${entry.name}`;
      if (entry.isDirectory()) {
        return excludedDirectories.has(entry.name)
          ? []
          : listFiles(root, path, extensions);
      }
      return entry.isFile() && extensions.has(extname(entry.name))
        ? [path]
        : [];
    }),
  );
  return paths.flat();
}

async function existingDocuments(root) {
  const paths = await Promise.all(
    documents.map(async (path) => {
      try {
        return (await lstat(resolve(root, path))).isFile() ? [path] : [];
      } catch (error) {
        if (error.code === "ENOENT") return [];
        throw error;
      }
    }),
  );
  return paths.flat();
}

function metadata(path, url, content) {
  return {
    path,
    url,
    bytes: content.length,
    sha256: createHash("sha256").update(content).digest("hex"),
  };
}

function indexPage(files, assets) {
  const source = files
    .map(
      ({ path, url, content }) => `
    <details id="${escapeHtml(path)}">
      <summary>${escapeHtml(path)}</summary>
      <p><a href="../${escapeHtml(url)}">Read raw text</a></p>
      <pre><code>${escapeHtml(content)}</code></pre>
    </details>`,
    )
    .join("\n");
  const assetLinks = assets
    .map(
      ({ path, url }) =>
        `<li><a href="../${escapeHtml(url)}">${escapeHtml(path)}</a></li>`,
    )
    .join("\n");
  return `<!doctype html>
<html lang="en">
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>DualEntry landing page — readable source</title>
  <link rel="describedby" type="application/json" href="manifest.json">
  <style>body{max-width:1000px;margin:48px auto;padding:0 24px;font:16px/1.6 system-ui;color:#1d1f20;background:#fff}h1{font-weight:400;line-height:1.2}a{color:#004f5c}details{border-top:1px solid #dfe9eb;padding:16px 0}summary{cursor:pointer;overflow-wrap:anywhere}pre{overflow:auto;background:#f4f6f6;padding:20px;font-size:13px;line-height:1.55}nav{display:flex;flex-wrap:wrap;gap:20px;margin:24px 0}li{overflow-wrap:anywhere}</style>
</head>
<body>
  <h1>DualEntry landing page source</h1>
  <p>Complete authored HTML, CSS, JavaScript, build tools, tests, and local asset references. Expand a file to read it, or fetch the complete text bundle to recreate the project.</p>
  <nav aria-label="Source downloads"><a href="../">Landing page</a><a href="manifest.json">File manifest and SHA-256 hashes</a><a href="bundle.json">All source text as JSON</a></nav>
  <main><h2>Source files</h2>${source}<h2>Assets</h2><ul>${assetLinks}</ul></main>
</body>
</html>\n`;
}

export async function publishSource(root, destination) {
  const paths = (
    await Promise.all([
      ...textRoots.map((directory) =>
        listFiles(root, directory, textExtensions),
      ),
      existingDocuments(root),
    ])
  )
    .flat()
    .sort();
  const files = await Promise.all(
    paths.map(async (path) => {
      const raw = await readFile(resolve(root, path));
      const content = raw.toString("utf8");
      // Fail visibly rather than expose machine-specific source or silently redact code.
      const localPath = new RegExp(
        "/(?:Users|Volumes|home)/[^\\s]+|[A-Za-z]:\\\\Users\\\\",
      );
      if (localPath.test(content))
        throw new Error(`Machine-specific path in public source: ${path}`);
      const url = `source/files/${path.split("/").map(encodeURIComponent).join("/")}.txt`;
      return { ...metadata(path, url, raw), content };
    }),
  );
  const assetPaths = (await listFiles(root, "assets", assetExtensions)).sort();
  const assets = await Promise.all(
    assetPaths.map(async (path) =>
      metadata(
        path,
        path.split("/").map(encodeURIComponent).join("/"),
        await readFile(resolve(root, path)),
      ),
    ),
  );
  const manifest = {
    version: 1,
    files: files.map(({ content, ...entry }) => entry),
    assets,
  };
  const directory = resolve(destination, "source");
  await mkdir(directory, { recursive: true });
  await Promise.all(
    files.map(async ({ url, content }) => {
      const output = resolve(destination, decodeURIComponent(url));
      await mkdir(dirname(output), { recursive: true });
      await writeFile(output, content);
    }),
  );
  await Promise.all([
    writeFile(
      resolve(directory, "manifest.json"),
      JSON.stringify(manifest, null, 2) + "\n",
    ),
    writeFile(
      resolve(directory, "bundle.json"),
      JSON.stringify({ version: 1, files, assets }, null, 2) + "\n",
    ),
    writeFile(resolve(directory, "index.html"), indexPage(files, assets)),
  ]);
  return manifest;
}