// What a channel's videos are CALLED, for the editor's per-channel video list
// and the video page — without downloading anything and without walking the
// corpus.
//
// Three sources, cheapest first, first hit wins:
//
//   1. "index"    — the LMDB `sums` sub-DB (TranscriptSummary.title), read by a
//                   key range over `byChannel` for this one channel. Covers the
//                   videos the index admitted, i.e. those with a
//                   metadata.info.json on disk at the last build.
//   2. "scan"     — channels/<slug>/metadata-scan.json (metadataScanStore.ts):
//                   listed-but-undownloaded videos, only after a metadata scan.
//                   ONE file read for the whole channel.
//   3. "metadata" — data/<id>/metadata.info.json, for the remainder only
//                   (downloaded after the last index build, or a directory
//                   name that is not the index's metadata id — see below). A
//                   head read per id, not a full parse: some of these files
//                   are hundreds of KB.
//
// THE INDEX IS KEYED BY METADATA ID, THE LIST BY DIRECTORY NAME. On most
// channels they are the same string; on Rumble the directory is the URL slug
// and the metadata id is the embed id (recencyIndex.ts's layer-1 comment). A
// miss there is not wrong, it just falls through to source 3 and costs a file
// read. Nothing is matched fuzzily, so a title is never attributed to the
// wrong video.
//
// Read-only throughout: the index is opened `readOnly`, the scan store through
// its own loader, and no video directory is created (the scan store's
// invariant).

import { existsSync } from "node:fs";
import { open as openFile, readdir, stat } from "node:fs/promises";
import path from "node:path";
import { open } from "lmdb";
import type { Paths } from "../lib/paths";
import type { TranscriptSummary } from "../lib/transcripts";
import { loadRawMetadataFromDir } from "../lib/transcripts-server";
import { mapConcurrent } from "../lib/concurrency";
import { loadMetadataScan } from "./metadataScanStore";

export type VideoTitleSource = "index" | "scan" | "metadata";

export type VideoTitle = { title: string; source: VideoTitleSource };

// buildIndex.ts's key shapes: sums is [uploadDate, slug, id], byChannel is
// [slug, uploadDate, id].
type IndexKey = [string, string, string];
type ChannelKey = [string, string, string];

// yt-dlp writes `"id"` then `"title"` first in metadata.info.json, so 16 KB of
// head finds the top-level title without reading the formats/subtitles tail.
const HEAD_BYTES = 16384;
const TITLE_RE = /"title":\s*("(?:[^"\\]|\\.)*")/;
const METADATA_READ_CONCURRENCY = 16;

function channelDataDir(paths: Paths, slug: string): string {
  return path.join(paths.channelsDir, slug, "data");
}

// Source 1. Never throws: a missing, locked or mid-rebuild index is "no
// titles from the index", and the other two sources carry on.
function readIndexTitles(
  paths: Paths,
  slug: string,
  wanted: ReadonlySet<string>,
  out: Map<string, VideoTitle>,
): void {
  if (wanted.size === 0 || !existsSync(paths.lmdbPath)) return;
  let root: ReturnType<typeof open>;
  try {
    // `compression: true` is not optional on a reader: buildIndex writes with
    // it, and without it every value over ~1 KB (any real description) throws
    // on decode. See curatedTagsPreview.ts's openIndex.
    root = open({
      path: paths.lmdbPath,
      readOnly: true,
      maxDbs: 18,
      compression: true,
    });
  } catch {
    return;
  }
  try {
    const sums = root.openDB<TranscriptSummary, IndexKey>({
      name: "sums",
      encoding: "msgpack",
    });
    const byChannel = root.openDB<number, ChannelKey>({
      name: "byChannel",
      encoding: "msgpack",
    });
    // Key-only walk of this channel's range; a summary is decoded only for an
    // id the caller asked about.
    for (const { key } of byChannel.getRange({
      start: [slug],
      end: [slug, "￿"],
    })) {
      const ck = key as ChannelKey;
      if (ck[0] !== slug) break;
      const id = ck[2];
      if (!wanted.has(id) || out.has(id)) continue;
      const summary = sums.get([ck[1], ck[0], id]);
      const title = summary?.title;
      // summarize() falls back to the id when the metadata had no title — that
      // is not a title, so leave the id for a later source.
      if (typeof title === "string" && title.trim() && title !== id) {
        out.set(id, { title, source: "index" });
      }
    }
  } catch {
    // A partial read is still useful; whatever landed in `out` stands.
  } finally {
    void root.close().catch(() => {});
  }
}

// Source 3, one id. A head read and a regex; a full parse only when the head
// did not contain a title (an unusual key order, or a pretty-printer that put
// it later).
async function readMetadataTitle(videoDir: string): Promise<string | null> {
  const file = path.join(videoDir, "metadata.info.json");
  let head: string;
  try {
    const fh = await openFile(file, "r");
    try {
      const buf = Buffer.alloc(HEAD_BYTES);
      const { bytesRead } = await fh.read(buf, 0, HEAD_BYTES, 0);
      head = buf.subarray(0, bytesRead).toString("utf8");
    } finally {
      await fh.close();
    }
  } catch {
    return null;
  }
  const m = TITLE_RE.exec(head);
  if (m) {
    try {
      const t = JSON.parse(m[1]) as unknown;
      if (typeof t === "string" && t.trim()) return t;
    } catch {
      // fall through to the full parse
    }
  }
  const meta = await loadRawMetadataFromDir(videoDir);
  return typeof meta?.title === "string" && meta.title.trim()
    ? meta.title
    : null;
}

// --- The source-3 memo --------------------------------------------------------
//
// WHY: on a channel whose directory names never match the index (Rumble: dir =
// URL slug, index key = embed id; legacy `YYYYMMDD_<id>` dirs) EVERY row falls
// through to a metadata.info.json read, and the list page re-renders on every
// row click (force-dynamic, rows are `?video=` links). the-quartering-rumble has
// 8,049 such dirs: 5,024 ms cold / 224 ms warm per render, measured 2026-09-25.
//
// Per channel, keyed by the `data/` directory's mtime: adding or removing a
// video dir changes it, and the entry is then REBASED rather than dropped — the
// titles of the dirs still there carry over (one readdir, no file reads), and
// only the new dirs are read (release 8 review, V: a busy download lane adds a
// dir every few minutes, and each one used to re-read all 8,049). Rewriting a
// metadata.info.json INSIDE an existing dir does not — accepted, because a
// video's title does not change after download. Misses (no file yet, e.g. a dir
// mid-download) are NOT memoized, so a title that lands later is picked up.
// Held on globalThis because Next can load this module more than once.
const MEMO_MAX_CHANNELS = 64;

type TitleMemoEntry = { dataDirMtimeMs: number; titles: Map<string, string> };

declare global {
  var __yttVideoTitleMemo__: Map<string, TitleMemoEntry> | undefined;
}

function titleMemo(): Map<string, TitleMemoEntry> {
  return (globalThis.__yttVideoTitleMemo__ ??= new Map());
}

// For tests and the e2e reset (api/test/invalidate-cache).
export function resetVideoTitleMemo(): void {
  globalThis.__yttVideoTitleMemo__ = undefined;
}

// Test hook: metadata.info.json reads so far in this process (tests diff it).
let metadataReads = 0;
export function videoTitleMetadataReadCount(): number {
  return metadataReads;
}

async function memoForChannel(
  key: string,
  dataDir: string,
): Promise<Map<string, string> | null> {
  let mtimeMs: number;
  try {
    mtimeMs = (await stat(dataDir)).mtimeMs;
  } catch {
    return null; // no data/ — nothing to read, nothing to memoize
  }
  const memo = titleMemo();
  let entry = memo.get(key);
  if (!entry) {
    entry = { dataDirMtimeMs: mtimeMs, titles: new Map() };
  } else if (entry.dataDirMtimeMs !== mtimeMs) {
    // Keep the titles of the dirs that are still there; a removed dir's title
    // goes with it, so a re-listed id falls through to the other sources.
    let present: Set<string> | null = null;
    try {
      present = new Set(await readdir(dataDir));
    } catch {
      present = null;
    }
    const kept = new Map<string, string>();
    if (present) {
      for (const [id, title] of entry.titles) {
        if (present.has(id)) kept.set(id, title);
      }
    }
    entry = { dataDirMtimeMs: mtimeMs, titles: kept };
  }
  // Re-insert so iteration order is least-recently-used first.
  memo.delete(key);
  memo.set(key, entry);
  while (memo.size > MEMO_MAX_CHANNELS) {
    const oldest = memo.keys().next().value;
    if (oldest === undefined) break;
    memo.delete(oldest);
  }
  return entry.titles;
}

// Titles for `ids` of one channel. An id with no title from any source is
// absent from the map — the caller shows the id.
export async function readChannelVideoTitles(
  paths: Paths,
  channelSlug: string,
  ids: readonly string[],
): Promise<Map<string, VideoTitle>> {
  const out = new Map<string, VideoTitle>();
  if (ids.length === 0) return out;
  const wanted = new Set(ids);

  readIndexTitles(paths, channelSlug, wanted, out);

  if (out.size < wanted.size) {
    const scan = await loadMetadataScan(paths, channelSlug);
    for (const id of wanted) {
      if (out.has(id)) continue;
      const title = scan.entries[id]?.title;
      if (title && title.trim()) out.set(id, { title, source: "scan" });
    }
  }

  let remainder = [...wanted].filter((id) => !out.has(id));
  if (remainder.length > 0) {
    const dataDir = channelDataDir(paths, channelSlug);
    const memo = await memoForChannel(dataDir, dataDir);
    if (!memo) return out;
    remainder = remainder.filter((id) => {
      const title = memo.get(id);
      if (title === undefined) return true;
      out.set(id, { title, source: "metadata" });
      return false;
    });
    const titles = await mapConcurrent(
      remainder,
      METADATA_READ_CONCURRENCY,
      (id) => {
        metadataReads++;
        return readMetadataTitle(path.join(dataDir, id));
      },
    );
    remainder.forEach((id, i) => {
      const title = titles[i];
      if (title) {
        memo.set(id, title);
        out.set(id, { title, source: "metadata" });
      }
    });
  }
  return out;
}

export type VideoDisplayMetadata = {
  title?: string;
  description?: string;
  webpageUrl?: string;
  uploader?: string;
  uploadDate?: string;
  duration?: number;
  // "metadata" = data/<id>/metadata.info.json; "scan" = the channel's
  // metadata-scan.json entry (a listed video that was never downloaded);
  // "none" = neither exists, and the page shows the bare id.
  source: "metadata" | "scan" | "none";
};

function str(v: unknown): string | undefined {
  return typeof v === "string" && v !== "" ? v : undefined;
}

// The video page's header. metadata.info.json first — it is what the download
// wrote and carries the uploader and URL — else the scan entry.
export async function readVideoMetadataForDisplay(
  paths: Paths,
  channelSlug: string,
  id: string,
): Promise<VideoDisplayMetadata> {
  const meta = await loadRawMetadataFromDir(
    path.join(channelDataDir(paths, channelSlug), id),
  );
  if (meta) {
    return {
      title: str(meta.title),
      description: str(meta.description),
      webpageUrl: str(meta.webpage_url),
      uploader: str(meta.uploader),
      uploadDate: str(meta.upload_date),
      duration:
        typeof meta.duration === "number" && Number.isFinite(meta.duration)
          ? meta.duration
          : undefined,
      source: "metadata",
    };
  }
  const scan = await loadMetadataScan(paths, channelSlug);
  const entry = scan.entries[id];
  if (entry) {
    return {
      title: str(entry.title),
      description: str(entry.description),
      uploadDate: str(entry.uploadDate),
      duration: entry.duration,
      source: "scan",
    };
  }
  return { source: "none" };
}