import path from "node:path";
import { randomBytes, randomInt } from "node:crypto";
import { songDir } from "./browse";
import { readJson, withStateLock, writeJsonAtomic } from "./state";
import { emptyCompares, type Compare, type CompareDoc } from "./compare-types";

export * from "./compare-types";

// videos/<song>/compares.json, beside verdicts.json and for the same reason:
// a tree of songs is a thing that gets copied, and its judgements should travel
// with it. Written read-modify-write under withStateLock + writeJsonAtomic, so
// two tabs deciding at once cannot lose a row.

export const comparesFile = (id: string) => path.join(songDir(id), "compares.json");

export async function readCompares(id: string): Promise<CompareDoc> {
  const j = await readJson<CompareDoc>(comparesFile(id), emptyCompares());
  return j && typeof j === "object" && Array.isArray(j.compares) ? j : emptyCompares();
}

/** Append one observation. Never mutates an existing row. */
export async function appendCompare(id: string, c: Omit<Compare, "at">): Promise<Compare> {
  const row: Compare = { ...c, at: new Date().toISOString() };
  await withStateLock(async () => {
    const doc = await readCompares(id);
    doc.compares.push(row);
    await writeJsonAtomic(comparesFile(id), doc);
  });
  return row;
}

// ---------------------------------------------------------------------------
// Blind pairings.
//
// A <video src="/api/mix/media?path=videos/alpha/variants/wide-nokit.mp4"> is
// NOT blind. The label is in the DOM, in the network panel and in the
// right-click menu, and hiding the caption over it is theatre. So a blind
// pairing mints two opaque tokens and the bytes are served through them.
//
// The side order is decided HERE, once, server-side. Shuffling in the client
// meant a re-render could swap the panes mid-listen, and a preference recorded
// against panes that had since moved is worse than no preference.
//
// In memory, like lib/mix.ts: a pairing that does not survive a restart is a
// pairing worth minting again. The RECORD is on disk; only the anonymity is
// ephemeral.
// ---------------------------------------------------------------------------

export type Pairing = {
  id: string;
  song: string;
  cut: string;
  /** Rels in PRESENTATION order. */
  left: string;
  right: string;
  tokens: { left: string; right: string };
  at: number;
  /** Set once a call is recorded; a pairing is one observation, not a session. */
  spent: boolean;
};

const pairings = new Map<string, Pairing>();
const byToken = new Map<string, { pairing: string; side: "left" | "right" }>();

/** Half an hour is longer than any listen and short enough to stay small. */
const PAIRING_TTL_MS = 30 * 60 * 1000;

function sweep() {
  const cutoff = Date.now() - PAIRING_TTL_MS;
  for (const [id, p] of pairings) {
    if (p.at >= cutoff) continue;
    pairings.delete(id);
    byToken.delete(p.tokens.left);
    byToken.delete(p.tokens.right);
  }
}

const token = () => randomBytes(16).toString("hex");

export function mintPairing(song: string, cut: string, a: string, b: string): Pairing {
  sweep();
  // randomInt is the crypto one rather than Math.random: not for secrecy, but
  // because a biased shuffle in a controlled comparison is a systematic error
  // in the only measurement this tool takes.
  const flip = randomInt(2) === 1;
  const p: Pairing = {
    id: token(),
    song,
    cut,
    left: flip ? b : a,
    right: flip ? a : b,
    tokens: { left: token(), right: token() },
    at: Date.now(),
    spent: false,
  };
  pairings.set(p.id, p);
  byToken.set(p.tokens.left, { pairing: p.id, side: "left" });
  byToken.set(p.tokens.right, { pairing: p.id, side: "right" });
  return p;
}

export const getPairing = (id: string): Pairing | null => pairings.get(id) ?? null;

/** Which file a media token stands for, or null. */
export function resolveToken(t: string): { song: string; rel: string } | null {
  const hit = byToken.get(t);
  if (!hit) return null;
  const p = pairings.get(hit.pairing);
  if (!p) return null;
  return { song: p.song, rel: hit.side === "left" ? p.left : p.right };
}

/** What the client is allowed to know before it has decided: nothing but shape. */
export const blindView = (p: Pairing) => ({
  pairing: p.id,
  cut: p.cut,
  left: p.tokens.left,
  right: p.tokens.right,
});