#!/usr/bin/env bun
/**
 * Asserts that every committed `routeTree.gen.ts` matches what its generator
 * produces from the current route contract.
 *
 * The route trees are GENERATED (`bun run routes:gen` in each package, from
 * `tsr.routes.ts` / `consoleRoutes()`) but COMMITTED, because the build and the
 * type-level `Link to=...` checking both read them off disk. That makes them a
 * classic drift surface: change the route contract, forget to regenerate, and
 * the committed tree still compiles — the routes it lacks simply don't exist at
 * runtime.
 *
 * Nothing else catches it. The generated files open with a suppression pragma
 * that opts them out of type checking entirely, so `typecheck` cannot see a
 * missing route; lint doesn't read them semantically; and unit tests import
 * the very tree they are drifting against. This bug class has already escaped
 * once and shipped a live 404 for a route that was in the contract but not in
 * the committed tree.
 *
 * So: regenerate every tree into place, diff against git, and restore. The
 * generators are pure functions of the checked-in route config, so a clean
 * checkout is a no-op and any diff is real drift.
 *
 * Usage:
 *   bun run scripts/check-route-trees.ts
 */
import { spawnSync } from "node:child_process";
import { readFileSync, writeFileSync } from "node:fs";
import { resolve } from "node:path";

const repoRoot = resolve(import.meta.dir, "..");

/**
 * Every package with a committed route tree, as (workspace dir, tree path)
 * pairs. Each dir has a `routes:gen` script; the tree is the file it writes.
 */
const TREES = [
  { dir: "packages/react", tree: "packages/react/src/routes/routeTree.gen.ts" },
  { dir: "packages/app", tree: "packages/app/src/routeTree.gen.ts" },
  { dir: "apps/cloud", tree: "apps/cloud/src/routeTree.gen.ts" },
  { dir: "apps/host-selfhost", tree: "apps/host-selfhost/web/routeTree.gen.ts" },
  { dir: "apps/host-cloudflare", tree: "apps/host-cloudflare/web/routeTree.gen.ts" },
] as const;

const run = (command: string, args: readonly string[], cwd: string) =>
  spawnSync(command, [...args], { cwd, encoding: "utf8" });

/**
 * Compare on ROUTE CONTENT, not byte-for-byte.
 *
 * Two generators write these files: each package's `routes:gen` script, and the
 * TanStack vite plugin during `dev`. They agree on every route, import, and
 * type — they disagree only on blank lines in the trailing `declare module`
 * block. Comparing raw bytes would therefore fail on any checkout where a dev
 * server had run, which is a false alarm about formatting, not the drift this
 * guards (a route present in the contract and missing from the tree). Blank
 * lines cannot encode a route, so dropping them loses no signal.
 */
const routeContent = (source: string): string =>
  source
    .split("\n")
    .filter((line) => line.trim() !== "")
    .join("\n");

// Snapshot the committed content so a failed run leaves the checkout exactly as
// it found it — this script must be safe to run on a dirty working tree.
const before = new Map<string, string>();
for (const { tree } of TREES) {
  before.set(tree, readFileSync(resolve(repoRoot, tree), "utf8"));
}

const restore = () => {
  for (const [tree, content] of before) writeFileSync(resolve(repoRoot, tree), content);
};

/** The lines each side has and the other does not — enough to name the route
 *  that drifted, without pulling in a diff library for a CI guard. */
const lineDiff = (committed: string, regenerated: string): string => {
  const committedLines = new Set(committed.split("\n"));
  const regeneratedLines = new Set(regenerated.split("\n"));
  const missing = [...regeneratedLines].filter((line) => !committedLines.has(line));
  const extra = [...committedLines].filter((line) => !regeneratedLines.has(line));
  const show = (label: string, lines: readonly string[]) =>
    lines.length === 0
      ? []
      : [`    ${label}:`, ...lines.slice(0, 20).map((line) => `      ${line}`)];
  return [
    ...show("in the regenerated tree but NOT committed (missing routes)", missing),
    ...show("committed but NOT regenerated (stale routes)", extra),
  ].join("\n");
};

type Failure = { readonly tree: string; readonly detail: string };
const failures: Failure[] = [];

for (const { dir, tree } of TREES) {
  const generated = run("bun", ["run", "routes:gen"], resolve(repoRoot, dir));
  if (generated.status !== 0) {
    failures.push({
      tree,
      detail: `\`bun run routes:gen\` failed in ${dir}:\n${generated.stderr || generated.stdout}`,
    });
    continue;
  }
  const after = readFileSync(resolve(repoRoot, tree), "utf8");
  const committed = routeContent(before.get(tree) ?? "");
  const regenerated = routeContent(after);
  if (regenerated !== committed) {
    // Show the actual drift rather than just naming the file: what changed is
    // usually the whole answer (a route added to the contract, or removed).
    // Diffed against the SNAPSHOT rather than via `git diff`, so this reports
    // correctly even when the committed file was already dirty.
    failures.push({
      tree,
      detail: `regenerating produced a different tree:\n${lineDiff(committed, regenerated)}`,
    });
  }
}

restore();

if (failures.length > 0) {
  const lines = failures.map((f) => `  - ${f.tree}: ${f.detail}`).join("\n\n");
  console.error(
    `\nRoute-tree check FAILED (${failures.length} tree(s) out of date):\n${lines}\n\n` +
      "Cause: a committed routeTree.gen.ts does not match what its generator\n" +
      "produces from the current route contract — the contract changed and the\n" +
      "tree was not regenerated. These files opt out of type checking, so the\n" +
      "typecheck job cannot catch this; the app just serves a 404 for the\n" +
      "missing route.\n\n" +
      "Fix: regenerate and commit the trees:\n" +
      TREES.map(({ dir }) => `  bun run --cwd ${dir} routes:gen`).join("\n") +
      "\n",
  );
  process.exit(1);
}

console.log(`Route-tree check passed: ${TREES.length} generated tree(s) match their contract.`);