import path from "node:path";
import { createReadStream, type ReadStream } from "node:fs";
import { lstat, stat } from "node:fs/promises";
import { NextResponse } from "next/server";
import { getPaths } from "yt-dlp-transcript-common/lib/paths";
import { makeSafeController } from "yt-dlp-transcript-common/lib/safeStreamController";
import { readChannelConfig } from "yt-dlp-transcript-common/controller/channels";
import {
  channelMediaStall,
  channelTextStall,
} from "yt-dlp-transcript-common/lib/channelMedia";
import { isTierable } from "yt-dlp-transcript-common/lib/mediaTier";
import {
  NOT_ANSWERING,
  isDriveNotAnswering,
  onDrive,
} from "yt-dlp-transcript-common/lib/storageHealth";

export const dynamic = "force-dynamic";

const SAFE_SEGMENT = /^[A-Za-z0-9._-]+$/;

const MIME_BY_EXT: Record<string, string> = {
  mp3: "audio/mpeg",
  m4a: "audio/mp4",
  aac: "audio/aac",
  ogg: "audio/ogg",
  opus: "audio/ogg",
  wav: "audio/wav",
  flac: "audio/flac",
  mp4: "video/mp4",
  webm: "video/webm",
  mkv: "video/x-matroska",
  mov: "video/quicktime",
  vtt: "text/vtt; charset=utf-8",
  json: "application/json; charset=utf-8",
};

function contentTypeFor(name: string): string {
  const dot = name.lastIndexOf(".");
  const ext = dot >= 0 ? name.slice(dot + 1).toLowerCase() : "";
  return MIME_BY_EXT[ext] ?? "application/octet-stream";
}

// Wrap a Node ReadStream as a WHATWG ReadableStream that survives the browser
// aborting the response mid-flight. The browser does this constantly while
// scrubbing an <audio>/<video> element — each seek cancels the prior range
// request. `Readable.toWeb(...)` was previously here, but it can call enqueue
// on the WHATWG controller AFTER the consumer cancelled, surfacing
// `ERR_INVALID_STATE: Controller is already closed` as an uncaughtException.
function nodeStreamToResponseBody(
  node: ReadStream,
): ReadableStream<Uint8Array> {
  const safe = makeSafeController<Uint8Array>();
  return new ReadableStream<Uint8Array>({
    start(controller) {
      safe.setController(controller);
      node.on("data", (chunk: Buffer | string) => {
        const bytes =
          typeof chunk === "string"
            ? new TextEncoder().encode(chunk)
            : new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
        safe.safeEnqueue(bytes);
      });
      node.on("end", () => {
        safe.safeClose();
      });
      node.on("error", (err) => {
        safe.safeError(err);
      });
    },
    cancel() {
      safe.markClosed();
      node.destroy();
    },
  });
}

function parseRange(
  header: string | null,
  size: number,
): { start: number; end: number } | null {
  if (!header) return null;
  const m = /^bytes=(\d*)-(\d*)$/.exec(header.trim());
  if (!m) return null;
  const startRaw = m[1];
  const endRaw = m[2];
  let start: number;
  let end: number;
  if (startRaw === "" && endRaw !== "") {
    // suffix range: bytes=-N → last N bytes
    const n = Number.parseInt(endRaw, 10);
    if (!Number.isFinite(n) || n <= 0) return null;
    start = Math.max(0, size - n);
    end = size - 1;
  } else if (startRaw !== "") {
    start = Number.parseInt(startRaw, 10);
    end = endRaw === "" ? size - 1 : Number.parseInt(endRaw, 10);
    if (!Number.isFinite(start) || !Number.isFinite(end)) return null;
  } else {
    return null;
  }
  if (start < 0 || end >= size || start > end) return null;
  return { start, end };
}

export async function GET(
  request: Request,
  {
    params,
  }: { params: Promise<{ slug: string; id: string; name: string }> },
) {
  const { slug, id, name } = await params;
  if (!SAFE_SEGMENT.test(slug) || !SAFE_SEGMENT.test(name)) {
    return NextResponse.json({ error: "Invalid path" }, { status: 400 });
  }
  // Video IDs may include URL-encoded characters; decode then validate.
  const decodedId = decodeURIComponent(id);
  if (!SAFE_SEGMENT.test(decodedId)) {
    return NextResponse.json({ error: "Invalid id" }, { status: 400 });
  }

  const paths = getPaths();
  const fullPath = path.resolve(
    paths.channelsDir,
    slug,
    "data",
    decodedId,
    name,
  );
  const expectedPrefix =
    path.resolve(paths.channelsDir, slug, "data", decodedId) + path.sep;
  if (!fullPath.startsWith(expectedPrefix)) {
    return NextResponse.json({ error: "Forbidden" }, { status: 403 });
  }

  // A drive that is not answering is not asked: the stat and the stream would
  // each wait on it. 503, because it is a state that passes. The stat goes
  // through the watchdog, so a drive that stops answering now is a 503 too;
  // the stream that follows a stat that answered is not raced.
  const notAnswering = () =>
    NextResponse.json(
      { error: `Media not read: ${NOT_ANSWERING}.` },
      { status: 503, headers: { "retry-after": "15" } },
    );
  // THE DRIVE IS CHOSEN BY WHERE THE FILE IS (release 17). A TIERED file — a
  // link (the `lstat` says so, on the corpus disk) with a tierable name — is on
  // the media tier's drive, `mediaDir`, so its stat goes through that drive's
  // watchdog and a stalled media drive refuses it. Everything else — the text,
  // and a real file the tier never takes (`source-media.*`, a partial) — is on
  // the corpus disk and is read directly: a stalled media drive never holds a
  // transcript. (A legacy channel's whole `data/` is on its retired `dataDir`.)
  const channelConfig = await readChannelConfig(paths, slug);
  // THE TEXT STALL FIRST, with no I/O: on a legacy channel `data/` itself is a
  // link onto the far drive, so even the `lstat` below would reach a drive
  // already known not to answer (review R1).
  if (channelTextStall(channelConfig)) return notAnswering();
  const mediaDir = channelConfig?.mediaDir?.trim() || undefined;
  const legacyDrive = channelConfig?.dataDir?.trim() || undefined;
  // A legacy channel has no tiered links: its whole `data/` is on the retired
  // drive, read through the watchdog below — no `lstat` of it here.
  const isLink = legacyDrive
    ? false
    : await lstat(fullPath)
        .then((l) => l.isSymbolicLink())
        .catch(() => false);
  const onMediaTier = isLink && isTierable(name);
  if (onMediaTier && channelMediaStall(channelConfig)) return notAnswering();
  const drive = onMediaTier ? mediaDir || legacyDrive : legacyDrive;

  let stats;
  try {
    stats = await (drive ? onDrive(drive, () => stat(fullPath)) : stat(fullPath));
  } catch (err) {
    if (isDriveNotAnswering(err)) return notAnswering();
    // A LINK WHOSE TARGET IS NOT THERE, on a channel whose media is on
    // another drive, is a tiered file on a drive that is unmounted (or renamed
    // away): the file exists, its bytes are not reachable now. 503 with a
    // retry, never 404 — a 404 tells a player, and an operator, that there is
    // no such file. On an in-place `media/` (no `mediaDir`) a dangling link is
    // a file that is gone, and that IS a 404 (review N8).
    if (onMediaTier && mediaDir) {
      return NextResponse.json(
        {
          error:
            `Media not read: ${name} is on this channel's media drive, which ` +
            `is not mounted or not answering.`,
        },
        { status: 503, headers: { "retry-after": "15" } },
      );
    }
    return NextResponse.json({ error: "Not found" }, { status: 404 });
  }
  if (!stats.isFile()) {
    return NextResponse.json({ error: "Not a file" }, { status: 404 });
  }

  const size = stats.size;
  const type = contentTypeFor(name);
  const rangeHeader = request.headers.get("range");
  const range = parseRange(rangeHeader, size);

  if (range) {
    const { start, end } = range;
    const length = end - start + 1;
    const stream = nodeStreamToResponseBody(
      createReadStream(fullPath, { start, end }),
    );
    return new Response(stream, {
      status: 206,
      headers: {
        "Content-Type": type,
        "Content-Length": String(length),
        "Content-Range": `bytes ${start}-${end}/${size}`,
        "Accept-Ranges": "bytes",
        "Cache-Control": "no-store",
      },
    });
  }

  const stream = nodeStreamToResponseBody(createReadStream(fullPath));
  return new Response(stream, {
    status: 200,
    headers: {
      "Content-Type": type,
      "Content-Length": String(size),
      "Accept-Ranges": "bytes",
      "Cache-Control": "no-store",
    },
  });
}