// Revisions of a manifest, instead of `.bak` files copied by hand.
//
// Five real projects revise by copying: quartering-employee-count has five
// `video.manifest.json.*.bak` files, ferret-rescue one, quartering-gout a
// hand-copied `video.manifest.noqr.json`. This gives that practice a shape --
// `revisions/<stamp>[-<label>].manifest.json`, a subdirectory so the project
// walk (a project is a leaf; `revisions` is in SKIP_DIRS besides) never mistakes
// one for a project -- and LISTS the legacy files beside it, by mtime, as
// unlabelled snapshots. Reported, never renamed, never guessed at.
//
// Plain ESM: `umtool snapshot` and `umtool diff` run from a terminal.
import { copyFile, mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
import path from "node:path";
import { MANIFEST_NAME } from "../projects/report.mjs";

export const REVISIONS_DIR = "revisions";

/** `20260825-143012`, seconds included: two snapshots a minute apart must not collide. */
export function stampOf(d = new Date()) {
  const p = (n) => String(n).padStart(2, "0");
  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
}

const LABEL_RE = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;

/** A snapshot's file name, or null when the name is not one. */
export function parseSnapshotName(name) {
  const m = name.match(/^(\d{8}-\d{6})(?:-(.+))?\.manifest\.json$/);
  if (!m) return null;
  return { stamp: m[1], label: m[2] ?? null };
}

/**
 * The legacy shapes, as they exist on disk:
 *   video.manifest.json.bak            the writer's own rate-limited backup
 *   video.manifest.json.<x>.bak        employee-count's five
 *   video.manifest.<x>.json            gout's noqr copy
 * `<x>` is kept as the label because it is the only name the author gave it.
 */
export function parseLegacyName(name) {
  if (name === MANIFEST_NAME) return null;
  let m = name.match(/^video\.manifest\.json(?:\.(.+))?\.bak$/);
  if (m) return { label: m[1] ?? null, legacy: true };
  m = name.match(/^video\.manifest\.(.+)\.json$/);
  if (m && !m[1].includes(".tmp-")) return { label: m[1], legacy: true };
  return null;
}

/**
 * Every snapshot, newest first. `rel` is project-relative and is what the diff
 * and the page address a snapshot by; nothing here accepts a bare path.
 * @returns {Promise<Array<{ rel: string, name: string, stamp: string | null, label: string | null, legacy: boolean, mtimeMs: number, size: number }>>}
 */
export async function listSnapshots(dir) {
  const out = [];
  const revDir = path.join(dir, REVISIONS_DIR);
  for (const name of await readdir(revDir).catch(() => [])) {
    const p = parseSnapshotName(name);
    if (!p) continue;
    const st = await stat(path.join(revDir, name)).catch(() => null);
    if (!st) continue;
    out.push({ rel: path.posix.join(REVISIONS_DIR, name), name, stamp: p.stamp, label: p.label, legacy: false, mtimeMs: st.mtimeMs, size: st.size });
  }
  for (const name of await readdir(dir).catch(() => [])) {
    const p = parseLegacyName(name);
    if (!p) continue;
    const st = await stat(path.join(dir, name)).catch(() => null);
    if (!st?.isFile()) continue;
    out.push({ rel: name, name, stamp: null, label: p.label, legacy: true, mtimeMs: st.mtimeMs, size: st.size });
  }
  return out.sort((a, b) => b.mtimeMs - a.mtimeMs || a.name.localeCompare(b.name));
}

/** Resolve a project-relative snapshot name to a path, refusing anything else. */
export function snapshotPath(dir, rel) {
  const r = String(rel ?? "");
  if (!r || r.includes("..") || path.isAbsolute(r)) return null;
  const inRev = r.startsWith(`${REVISIONS_DIR}/`) && parseSnapshotName(r.slice(REVISIONS_DIR.length + 1));
  if (!inRev && !parseLegacyName(r)) return null;
  return path.join(dir, r);
}

/**
 * Copy the manifest into revisions/. The copy is byte-for-byte: a snapshot
 * that was re-serialised would diff against its own source.
 */
/**
 * @param {string} dir
 * @param {{ label?: string | null, now?: Date }} [opts]
 */
export async function createSnapshot(dir, { label = null, now = new Date() } = {}) {
  if (label !== null && !LABEL_RE.test(String(label))) {
    throw new Error(`a label is letters, digits, dots, dashes and underscores — not "${label}"`);
  }
  const src = path.join(dir, MANIFEST_NAME);
  if (!(await stat(src).then((s) => s.isFile(), () => false))) throw new Error(`no ${MANIFEST_NAME} in ${dir}`);
  await mkdir(path.join(dir, REVISIONS_DIR), { recursive: true });
  const name = `${stampOf(now)}${label ? `-${label}` : ""}.manifest.json`;
  const dst = path.join(dir, REVISIONS_DIR, name);
  if (await stat(dst).then(() => true, () => false)) throw new Error(`${name} already exists — wait a second`);
  await copyFile(src, dst);
  return { rel: path.posix.join(REVISIONS_DIR, name), name };
}

/**
 * The build's "stamp aside" of a deliverable, recorded as a snapshot of the
 * manifest that produced it. The label names the moved file so the pairing is
 * visible in the directory listing without opening anything.
 */
export async function recordBuildSnapshot(dir, asideName) {
  const label = `built-${String(asideName).replace(/\.mp4$/, "").replace(/[^A-Za-z0-9._-]/g, "_")}`;
  return createSnapshot(dir, { label });
}

export async function readSnapshot(dir, rel) {
  const file = snapshotPath(dir, rel);
  if (!file) throw new Error(`not a snapshot of this project: ${rel}`);
  return JSON.parse(await readFile(file, "utf8"));
}

/** Exposed for tests: write a snapshot with a given stamp. */
export async function writeSnapshotRaw(dir, name, text) {
  await mkdir(path.join(dir, REVISIONS_DIR), { recursive: true });
  await writeFile(path.join(dir, REVISIONS_DIR, name), text, "utf8");
}