// The face-judging shapes AND the crop maths, with NO server imports.
//
// Same boundary rule as lib/note-types.ts and lib/phrase-types.ts, and for the
// same reason: FaceDeck.tsx needs CORNER_PX, autoCrop() and the reason list as
// VALUES at runtime. A value import is not erased, so one that reaches
// lib/faces.ts -> node:fs would follow into the client chunk and fail the
// build -- a break `tsc --noEmit` cannot see and only the bundler catches.

/** CORNER_W / CORNER_H in make-thumb.mjs. The corner is square and 300px. */
export const CORNER_PX = 300;

/** facecrop.py's `side = max(fw, fh) * 2.2` -- a portrait, not a nose. */
export const PAD = 2.2;

/**
 * How far off the face centre a crop has to sit before it is worth saying.
 *
 * Not zero, because facecrop.py truncates the crop origin to whole pixels, so
 * a perfectly centred crop still reports up to half a pixel of displacement.
 * Eight is comfortably above that and far below the 93px that put YouTube
 * chrome in the bottom-left corner of the Super Mario RPG cover.
 */
export const SHOVE_FLOOR = 8;

/** A rectangle in SOURCE pixels. Never in canvas or preview pixels. */
export type Box = { x: number; y: number; w: number; h: number };

export type FaceBox = Box & { score: number; t: number };

export type FaceVerdict = "clean" | "recrop" | "reject";

export type FaceJudgement = {
  /** `<video>@<srcStart>` -- the SAME clip key notes, verdicts and state use. */
  key: string;
  video: string;
  verdict: FaceVerdict;
  code?: number;
  text?: string;
  frameAt: number;
  /** The human's framing, in source pixels. */
  crop?: Box;
  /** What facecrop.py would have done, kept so the diff survives the session. */
  auto?: Box;
  at: string;
};

// ---------------------------------------------------------------------------
// The reason codes.
//
// APPEND-ONLY and 1-based, exactly as song/reasons.mjs is and for the same
// reason -- the number is what gets stored, so renumbering would rewrite
// history. It is its OWN list rather than a slice of that one because these are
// faults of the PICTURE, not of the clip: "stream UI in frame" is not a thing
// that can be wrong with a sound, and "pop / plosive" is not a thing that can
// be wrong with a crop.
// ---------------------------------------------------------------------------

export const FACE_REASONS = [
  "stream UI in frame",   // 1  the chrome, the chat, the inset's own border
  "blink or mid-word",    // 2
  "motion blurred",       // 3
  "not Jer",              // 4
  "face too small",       // 5
];

/** Free text, for whatever the fixed list does not cover. As reasons.mjs has it. */
export const OTHER_CODE = 99;

export const reasonText = (code: number | undefined, text?: string): string => {
  if (code === OTHER_CODE) return text ?? "other";
  if (!code) return "";
  return FACE_REASONS[code - 1] ?? `reason ${code}`;
};

// ---------------------------------------------------------------------------
// The crop, computed here as well as there.
//
// A pure re-implementation of facecrop.py's crop maths, exactly as
// verifyUniqueFaces() is a pure re-implementation of accept-thumb.mjs's rule.
// That is what lets the deck draw WHAT THE CLI WOULD DO beside WHAT YOU CHOSE,
// on every drag, without a round trip -- and lets a test assert the two agree
// without spawning python.
//
// It also returns `shove`, which is the whole point of the tool. The clamp on
// the last two lines preserves the crop's SIZE at the cost of moving it OFF the
// face: a webcam inset is always near a frame edge, so when the padded box
// overruns the edge the crop slides inward and fills with whatever sits beside
// the webcam. That displacement is not a rounding error, it is the YouTube
// chrome. Measured, it is a number; unmeasured, it is a mystery.
// ---------------------------------------------------------------------------

export function autoCrop(
  face: Box,
  frameW: number,
  frameH: number,
  aspect = 1,
): { box: Box; shove: number } {
  const cx = face.x + face.w / 2;
  const cy = face.y + face.h / 2;

  let side = Math.max(face.w, face.h) * PAD;
  side = Math.min(side, Math.min(frameW, frameH));

  // The face box sets the HEIGHT; the width follows the aspect, so a 16:9 crop
  // is a square one with more room either side rather than the same picture
  // zoomed out.
  let ch = side;
  let cwid = side * aspect;
  if (cwid > frameW) {
    cwid = frameW;
    ch = Math.min(ch, cwid / aspect);
  }

  // Math.trunc, not Math.round: python's int() truncates, and a crop that
  // disagreed with the CLI by a pixel would make every comparison approximate.
  const x = Math.trunc(Math.max(0, Math.min(frameW - cwid, cx - cwid / 2)));
  const y = Math.trunc(Math.max(0, Math.min(frameH - ch, cy - ch / 2)));
  const box: Box = { x, y, w: Math.trunc(cwid), h: Math.trunc(ch) };

  return { box, shove: Math.hypot(box.x + box.w / 2 - cx, box.y + box.h / 2 - cy) };
}

/**
 * What the corner is resampled by: 300px of output over the crop's own height.
 *
 * Below 1 the crop is being shrunk and detail is spare. Above 1 it is being
 * BLOWN UP and the corner is softer than the source -- which is the price of
 * cropping in past stream UI, and the price is the human's to pay or refuse.
 * Half the corners on record already upscale, so this is not a rare warning.
 */
export const scaleOf = (box: Box): number => (box.h > 0 ? CORNER_PX / box.h : 0);

export const keyOf = (video: string, srcStart: number): string =>
  `${video}@${(+srcStart).toFixed(2)}`;

/** Whole pixels, and inside the frame. A crop is cut with integer slices. */
export function boxInFrame(box: Box, frameW: number, frameH: number): boolean {
  const finite = [box.x, box.y, box.w, box.h].every((n) => Number.isFinite(n));
  if (!finite) return false;
  if (box.w < 1 || box.h < 1) return false;
  return box.x >= 0 && box.y >= 0 && box.x + box.w <= frameW && box.y + box.h <= frameH;
}

/** Round to whole pixels and slide (never shrink, unless it must) into frame. */
export function clampBox(box: Box, frameW: number, frameH: number): Box {
  const w = Math.max(1, Math.min(frameW, Math.round(box.w)));
  const h = Math.max(1, Math.min(frameH, Math.round(box.h)));
  return {
    x: Math.max(0, Math.min(frameW - w, Math.round(box.x))),
    y: Math.max(0, Math.min(frameH - h, Math.round(box.y))),
    w,
    h,
  };
}

export const isVerdict = (v: unknown): v is FaceVerdict =>
  v === "clean" || v === "recrop" || v === "reject";

export const isBox = (v: unknown): v is Box => {
  if (!v || typeof v !== "object") return false;
  const b = v as Record<string, unknown>;
  return (["x", "y", "w", "h"] as const).every(
    (k) => typeof b[k] === "number" && Number.isFinite(b[k] as number),
  );
};