import { stat } from "node:fs/promises";
import { measureTree } from "yt-dlp-transcript-common/controller/relocateDir";

// THE SAVED-VIDEO STORE'S SIZE, MEASURED AT MOST ONCE EVERY 60 SECONDS.
//
// `measureTree` is a recursive walk. On /storage it is the one thing on the
// page that touches the disk per render rather than reading a report, and it
// is there because the store holds ONE container per pinned or kept-latest
// video — a few dozen files — not one per video. That is what makes a walk
// affordable at all.
//
// But "affordable" was doing a lot of work for a `force-dynamic` page the
// global AutoRefresh re-renders on a timer, and the store is the one directory
// in the corpus that can grow without anybody deciding it should: every pin,
// every `keepSourceVideo`, every umtool full-source fetch lands a container in
// it. A page that walks a growing directory on every refresh gets slower in
// exactly the situation the operator opened it to understand.
//
// KEYED BY THE DIRECTORY'S OWN MTIME, and capped at sixty seconds. The TTL
// alone was wrong and an e2e caught it within the hour: a spec seeded a
// container into the store and the page went on reporting "0 B in 0 file(s)"
// from a walk taken before the seed. A cache that makes a page lie about a
// number the operator just changed is worse than the walk it saves.
//
// Adding or removing an entry in a directory bumps THAT directory's mtime, so
// the common cases — the first container landing, a prune, a move that replaces
// the store with a symlink, an e2e reset — all invalidate on the next render.
// A write deeper in the tree (a container added inside an existing
// `<slug>/<video>/`) does not, which is what the sixty-second ceiling is still
// there for: the entry has to match on BOTH.
//
// One extra `stat` per render against a recursive walk is the trade. The
// store's SIZE is the only thing cached; its location, status and marker are
// read fresh every render, because those are the safety facts.
//
// `maxEntries` caps the map because the key is a path and a re-point changes
// it: without a cap a long-lived process that re-pointed repeatedly would keep
// one entry per historical root forever. The oldest insertion goes first (a
// Map iterates in insertion order), which is the right victim — the current
// root is always the most recently written.
//
// `measureTreeCached` is named in `common/controller/noCorpusWalkInRenderPaths.test.ts`'s
// allow map: `measureTree` is banned from render paths, and this module is the
// one place allowed to call it, precisely because of the cache above it.

export type MeasuredTree = { bytes: number; files: number };

const TTL_MS = 60_000;
const MAX_ENTRIES = 32;

type Entry = { at: number; mtimeMs: number; value: MeasuredTree };
const cache = new Map<string, Entry>();

// Test seam, and the escape hatch for a process that has just moved the store.
export function resetStoreMeasureCache(): void {
  cache.clear();
}

export async function measureTreeCached(
  dir: string,
  opts: { now?: number; refresh?: boolean } = {},
): Promise<MeasuredTree> {
  const now = opts.now ?? Date.now();
  // -1 when the directory is gone or unreadable: a value that can never equal a
  // real mtime, so a vanished store is always re-walked rather than answered
  // from a stale entry.
  const mtimeMs = await stat(dir).then(
    (st) => st.mtimeMs,
    () => -1,
  );
  if (!opts.refresh) {
    const hit = cache.get(dir);
    if (hit && hit.mtimeMs === mtimeMs && now - hit.at < TTL_MS) {
      return hit.value;
    }
  }
  const value = await measureTree(dir);
  // Delete before set so a refreshed key moves to the END of the insertion
  // order; otherwise the entry the page uses every minute would be the first
  // one evicted.
  cache.delete(dir);
  cache.set(dir, { at: now, mtimeMs, value });
  while (cache.size > MAX_ENTRIES) {
    const oldest = cache.keys().next();
    if (oldest.done) break;
    cache.delete(oldest.value);
  }
  return value;
}