import { createReadStream } from "node:fs";
import { stat } from "node:fs/promises";
import { Readable } from "node:stream";
import path from "node:path";

// ---------------------------------------------------------------------------
// Serving a whole render to a <video> element.
//
// RANGE SUPPORT IS NOT OPTIONAL HERE. The bench scrubs -- the entire point is
// jumping to 3.9s and listening -- and without 206 responses a <video> has to
// download the file from the start every time you seek, which on a 60 MB render
// turns each seek into a stall. This is also why the preview plays the real
// files rather than a re-encoded proxy: the moment you are judging has to be the
// moment that gets rendered.
//
// Lifted out of app/api/mix/media/route.ts when the blind bench needed a second
// route with EXACTLY these semantics. Not "similar" -- identical, including the
// suffix-range case below, because a blind comparison in which one side stalls
// is a comparison of the loading, not of the cut.
// ---------------------------------------------------------------------------

const TYPES: Record<string, string> = {
  ".mp4": "video/mp4",
  ".m4v": "video/mp4",
  ".mkv": "video/x-matroska",
  ".webm": "video/webm",
  ".mov": "video/quicktime",
  ".wav": "audio/wav",
  ".mp3": "audio/mpeg",
  ".m4a": "audio/mp4",
  ".aac": "audio/aac",
  ".flac": "audio/flac",
  ".ogg": "audio/ogg",
  // Cover art goes through the same door: the thumbnail bench shows candidate
  // frames that live in the reports tree, and an <img> served as
  // application/octet-stream is an <img> that may or may not draw.
  ".jpg": "image/jpeg",
  ".jpeg": "image/jpeg",
  ".png": "image/png",
  ".webp": "image/webp",
};

/** Byte-range aware delivery of one absolute path. Callers do the authorising. */
export async function serveFile(abs: string, request: Request): Promise<Response> {
  let size: number;
  try {
    size = (await stat(abs)).size;
  } catch {
    return new Response("no such file", { status: 404 });
  }

  const type = TYPES[path.extname(abs).toLowerCase()] ?? "application/octet-stream";
  const range = request.headers.get("range");
  const common = {
    "content-type": type,
    "accept-ranges": "bytes",
    "cache-control": "no-store",
  };

  if (!range) {
    const stream = Readable.toWeb(createReadStream(abs)) as ReadableStream;
    return new Response(stream, { headers: { ...common, "content-length": String(size) } });
  }

  const m = /^bytes=(\d*)-(\d*)$/.exec(range.trim());
  if (!m) return new Response("bad range", { status: 416, headers: { "content-range": `bytes */${size}` } });

  // An open-ended suffix range (`bytes=-500`) is legal and means the LAST n
  // bytes -- Chrome uses it to find an mp4's moov atom when it is not at the
  // front. Treating it as a start offset would hand back the wrong bytes and
  // the file would simply never play.
  let start: number;
  let end: number;
  if (m[1] === "") {
    const suffix = Number(m[2] || 0);
    if (!suffix) return new Response("bad range", { status: 416, headers: { "content-range": `bytes */${size}` } });
    start = Math.max(0, size - suffix);
    end = size - 1;
  } else {
    start = Number(m[1]);
    end = m[2] === "" ? size - 1 : Math.min(Number(m[2]), size - 1);
  }
  if (!Number.isFinite(start) || !Number.isFinite(end) || start > end || start >= size) {
    return new Response("bad range", { status: 416, headers: { "content-range": `bytes */${size}` } });
  }

  const stream = Readable.toWeb(createReadStream(abs, { start, end })) as ReadableStream;
  return new Response(stream, {
    status: 206,
    headers: {
      ...common,
      "content-range": `bytes ${start}-${end}/${size}`,
      "content-length": String(end - start + 1),
    },
  });
}