import { createReadStream } from "node:fs";
import { stat } from "node:fs/promises";
import { Readable } from "node:stream";
import { absOf, pickWindow, resolveClaim, resolveClip, windowsFor } from "@/lib/report/serve.mjs";
import { readClaimDetail } from "@/lib/projects/report.mjs";

export const dynamic = "force-dynamic";

// The cached source window, served WHOLE with byte ranges.
//
// The alternative -- an ffmpeg slice per requested window, like
// /api/clip/[key]/video does -- would put an encode in front of every drag. The
// file is small (one clip plus its pad), immutable (its window is in its name),
// and the browser only needs to be told where to seek: the bench sets
// currentTime = t - fetchStart and windows entirely on the client.
//
// Range support is not optional for that. Without a 206 the <video> element
// will not seek in a stream it did not fully download.

export async function GET(request: Request) {
  const url = new URL(request.url);
  const projectId = url.searchParams.get("project") ?? "";
  const claimId = url.searchParams.get("claim");

  // A CLAIM names a moment rather than a window, so its candidate files are the
  // cached windows that CONTAIN its cite. Everything below -- membership,
  // root-resolution, ranges, the immutable cache header -- is the clip path's,
  // unchanged: the two differ only in which list of windows they may pick from.
  let windows: Array<{ name: string; from: number; to: number; path: string }>;
  if (claimId) {
    const c = await resolveClaim(projectId, claimId);
    if ("error" in c) return new Response(c.error, { status: c.status });
    const detail = await readClaimDetail(c.project.dir, claimId, { manifest: c.manifest });
    windows = (detail?.windows ?? []) as typeof windows;
    // readClaimDetail returns names, not paths; re-resolve against the scan.
    const all = await windowsFor(c.project, { video: c.claim.video });
    windows = all.filter((w: { name: string }) => windows.some((x) => x.name === w.name));
  } else {
    const r = await resolveClip(projectId, url.searchParams.get("clip") ?? "");
    if ("error" in r) return new Response(r.error, { status: r.status });
    windows = await windowsFor(r.project, r.clip);
  }

  // A member of the server's own scan, never a path from the client.
  const win = pickWindow(windows, url.searchParams.get("file"));
  if (!win) return new Response("no cached window covering that moment", { status: 404 });
  const abs = absOf(win);
  if (!abs) return new Response("outside the roots", { status: 400 });

  const st = await stat(abs).catch(() => null);
  if (!st) return new Response("gone", { status: 404 });

  const headers: Record<string, string> = {
    "content-type": "video/mp4",
    "accept-ranges": "bytes",
    // The file is immutable -- rename the window and it is a different file --
    // so it may be cached hard. That is what makes dragging feel instant.
    "cache-control": "private, max-age=3600, immutable",
    // The absolute source second the file starts at, so the client can convert
    // without a second request.
    "x-fetch-start": String(win.from),
    "x-fetch-end": String(win.to),
    "x-window": win.name,
  };

  const range = request.headers.get("range");
  const m = range ? /^bytes=(\d*)-(\d*)$/.exec(range.trim()) : null;
  if (m) {
    const size = st.size;
    let start = m[1] ? Number(m[1]) : 0;
    let end = m[2] ? Number(m[2]) : size - 1;
    if (!m[1] && m[2]) {
      // A suffix range: the LAST n bytes.
      start = Math.max(0, size - Number(m[2]));
      end = size - 1;
    }
    if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= size) {
      return new Response(null, { status: 416, headers: { "content-range": `bytes */${size}` } });
    }
    end = Math.min(end, size - 1);
    const stream = createReadStream(abs, { start, end });
    return new Response(Readable.toWeb(stream) as ReadableStream, {
      status: 206,
      headers: {
        ...headers,
        "content-range": `bytes ${start}-${end}/${size}`,
        "content-length": String(end - start + 1),
      },
    });
  }

  return new Response(Readable.toWeb(createReadStream(abs)) as ReadableStream, {
    headers: { ...headers, "content-length": String(st.size) },
  });
}