import { readFile, realpath, stat } from "node:fs/promises";
import path from "node:path";
import { reportMediaDir, reportMediaIndexFile, siteReportDir } from "yt-dlp-transcript-common/publish/reportMedia";
import { rangeResponse } from "@/lib/report/serve.mjs";
import { CHANNELS_DIR, REPORTS_ROOT, SITES_DIR, inside } from "@/lib/paths";
import { sitesPaths } from "@/lib/articles/sites";

export const dynamic = "force-dynamic";

// Article media, READ-ONLY, with byte ranges (lib/report/serve.mjs
// rangeResponse, the one the cut player uses -- a <video> will not seek a
// stream it was not given a 206 for).
//
//   ?site&report&file   a file in the report's directory: video.mp4,
//                       poster.jpg, stills/… -- relative, no `..`, a media type,
//                       and its real path under SITES_DIR (or REPORTS_ROOT: a
//                       generator may link a take's preview in)
//   ?site&moment        the site's PREPARED evidence clip for a moment, found
//                       through report-media/index.json -- never a client path
//   ?corpus=<abs>       a clip window, saved video, audio or post capture in
//                       the corpus: lexically under CHANNELS_DIR (its real
//                       path is on whatever drive the media tier links to)
const TYPES: Record<string, string> = {
  ".mp4": "video/mp4",
  ".m4v": "video/mp4",
  ".webm": "video/webm",
  ".mkv": "video/x-matroska",
  ".mov": "video/quicktime",
  ".m4a": "audio/mp4",
  ".mp3": "audio/mpeg",
  ".opus": "audio/ogg",
  ".ogg": "audio/ogg",
  ".wav": "audio/wav",
  ".jpg": "image/jpeg",
  ".jpeg": "image/jpeg",
  ".png": "image/png",
  ".webp": "image/webp",
  ".gif": "image/gif",
};
const SEGMENT = /^[a-z0-9][a-z0-9-]{0,63}$/;

async function serve(request: Request, abs: string): Promise<Response> {
  const type = TYPES[path.extname(abs).toLowerCase()];
  if (!type) return new Response("not a media file", { status: 400 });
  const st = await stat(/* turbopackIgnore: true */ abs).catch(() => null);
  if (!st?.isFile()) return new Response("not found", { status: 404 });
  return rangeResponse(request, {
    abs,
    size: st.size,
    headers: { "content-type": type, "accept-ranges": "bytes", "cache-control": "private, no-store" },
  });
}

async function reportFile(site: string, report: string, rel: string): Promise<string | null> {
  if (!SEGMENT.test(site) || !SEGMENT.test(report)) return null;
  if (!rel || rel.includes("\0") || rel.startsWith("/") || rel.split("/").some((s) => s === ".." || s === "" || s === ".")) return null;
  const dir = siteReportDir(sitesPaths(), site, report);
  const abs = path.join(/* turbopackIgnore: true */ dir, rel);
  if (!inside(dir, abs)) return null;
  const real = await realpath(/* turbopackIgnore: true */ abs).catch(() => null);
  if (!real) return null;
  const roots = await Promise.all([SITES_DIR, REPORTS_ROOT].map((r) => realpath(/* turbopackIgnore: true */ r).catch(() => r)));
  return roots.some((r) => inside(r, real)) ? real : null;
}

async function preparedFile(site: string, moment: string): Promise<string | null> {
  if (!SEGMENT.test(site)) return null;
  try {
    const index = JSON.parse(await readFile(/* turbopackIgnore: true */ reportMediaIndexFile(sitesPaths(), site), "utf8"));
    const entry = index?.moments?.[moment];
    if (!entry || typeof entry.file !== "string") return null;
    const dir = reportMediaDir(sitesPaths(), site);
    const abs = path.resolve(/* turbopackIgnore: true */ dir, entry.file);
    return inside(dir, abs) ? abs : null;
  } catch {
    return null;
  }
}

export async function GET(request: Request) {
  const url = new URL(request.url);
  const q = (k: string) => url.searchParams.get(k) ?? "";
  if (url.searchParams.has("corpus")) {
    const abs = path.resolve(/* turbopackIgnore: true */ q("corpus"));
    if (abs !== q("corpus") || !inside(CHANNELS_DIR, abs)) return new Response("outside the corpus", { status: 400 });
    return serve(request, abs);
  }
  if (url.searchParams.has("moment")) {
    const abs = await preparedFile(q("site"), q("moment"));
    return abs ? serve(request, abs) : new Response("no prepared clip for that moment", { status: 404 });
  }
  const abs = await reportFile(q("site"), q("report"), q("file"));
  return abs ? serve(request, abs) : new Response("no such report file", { status: 404 });
}