import type {
  AutoQueueGroup,
  AutoQueueLeaf,
  AutoQueueNode,
  AutoQueueOrder,
} from "yt-dlp-transcript-common/jobs/autoQueuePolicy";
import { isGroup } from "yt-dlp-transcript-common/jobs/autoQueuePolicy";
import type { AutoRunnerIdleReason } from "yt-dlp-transcript-common/controller/autoRunner";
import type { AutoQueueKind } from "yt-dlp-transcript-common/jobs/autoQueueState";

// Shared vocabulary for the dispatcher board. Everything here turns a wire value
// into the words an operator would use, in one place, so the deck, the ladder
// and the next-up line cannot describe the same state three different ways.

export type Channel = { slug: string; name: string | null };

// --- Rules as sentences ------------------------------------------------------

// What a bucket actually means, in words. Deliberately NOT used for the bucket
// <select>'s option labels: an e2e spec asserts exactly one option named
// `downloadedAutoSubsOnly` page-wide, and the picker is also how an operator
// names a bucket to the runner — so the raw name stays there and the gloss lives
// in the rung's sentence.
const BUCKET_GLOSS: Record<string, string> = {
  downloadedNoTranscript: "downloaded, not transcribed",
  failedListed: "retries only",
  partialDownloads: "partial downloads",
  undownloadedIds: "not yet downloaded",
  downloadedAutoSubsOnly: "YouTube captions, audio in hand",
  autoSubsOnly: "YouTube captions",
};

export function bucketGloss(bucket: string | undefined): string {
  if (!bucket) return "all buckets";
  return BUCKET_GLOSS[bucket] ?? bucket;
}

// A leaf, read as a sentence rather than as a record: "cornbreadman · retries
// only" instead of "channel: cornbreadman [failedListed]".
export function leafSentence(leaf: AutoQueueLeaf, channels: Channel[]): string {
  const m = leaf.match;
  let who: string;
  if (m.type === "all") who = "any channel";
  else if (m.type === "channel") {
    const found = channels.find((c) => c.slug === m.value);
    who = m.value ? (found?.name ?? m.value) : "no channel picked";
  } else who = m.value ? `${m.value} channels` : "no platform picked";
  return `${who} · ${bucketGloss(m.bucket)}`;
}

// Plain-language gloss for a group's competition mode. The mode word alone
// ("strict") tells an operator nothing about what it does to their queue.
export const MODE_GLOSS: Record<string, string> = {
  strict: "first rule with work wins",
  "round-robin": "take turns between rules",
  "weighted-fair": "share by weight",
};

// Pre-order walk, matching flattenLeaves — the ORDINAL a rung shows is its
// position in this list, which is genuinely the priority order the engine reads.
export function leafOrder(root: AutoQueueNode): AutoQueueLeaf[] {
  if (!isGroup(root)) return [root];
  const out: AutoQueueLeaf[] = [];
  for (const child of (root as AutoQueueGroup).children) {
    out.push(...leafOrder(child));
  }
  return out;
}

// --- Ordering ----------------------------------------------------------------

export const ORDER_LABEL: Record<AutoQueueOrder, string> = {
  listed: "Listed order",
  newest: "Newest first",
  oldest: "Oldest first",
  // The digest lane's shortest-first. Named by DURATION, not by date, which is
  // why it is not a third arm of the recency axis.
  cheapest: "Shortest first",
};

// THE ORDERS A DATE-KEYED LANE OFFERS — the three this control has always
// offered. "cheapest" is deliberately not here: its comparator is supplied by
// the lane's runner (slice 1.2), and a lane whose runner has none falls back to
// "listed", so offering it would be a control that silently does nothing.
export const RECENCY_ORDERS: ReadonlyArray<AutoQueueOrder> = [
  "listed",
  "newest",
  "oldest",
];

// WHICH ORDERS EACH LANE OFFERS. A console must never show an option whose
// comparator does not exist — that is a control that silently does nothing —
// so this is keyed off what the runner can actually answer.
//
// Only the digest lane can price its work: every one of its candidates has a
// normalized transcript (that is what makes it reachable), and the duration is
// in that file's first 8 KB. A download candidate has nothing on disk at all,
// so `cheapest` on any other lane falls back to "listed" in the runner and is
// not offered here.
export const LANE_ORDERS: Record<
  AutoQueueKind,
  ReadonlyArray<AutoQueueOrder>
> = {
  transcription: RECENCY_ORDERS,
  download: RECENCY_ORDERS,
  digest: [...RECENCY_ORDERS, "cheapest"],
  backfill: RECENCY_ORDERS,
};

// The runner console's heading, per lane. PINNED: the e2e suite scopes whole
// tests on the <h2> text and on the "Start <title>" / "Drain <title>" /
// "Stop <title>" aria-labels built from it.
export const RUNNER_TITLE: Record<AutoQueueKind, string> = {
  transcription: "Auto-transcribe",
  download: "Auto-download",
  digest: "Auto-digest",
  backfill: "Auto-backfill",
};

export function orderTradeoff(
  kind: AutoQueueKind,
  order: AutoQueueOrder,
): string | null {
  // Neither of these reorders by upload date, so neither costs a retry or a
  // partial download its head start.
  if (order === "listed" || order === "cheapest") return null;
  // The trade-off named below is a DOWNLOAD/TRANSCRIPTION one — a retry or a
  // partial losing its head start. The operation lanes have no retry bucket and
  // no partial state to lose, so there is nothing to warn about.
  if (kind === "digest" || kind === "backfill") return null;
  return kind === "download"
    ? "Partial downloads lose their head start, so a half-finished download can wait behind fresh work."
    : "Retries lose their head start, so a failed video can wait behind fresh work.";
}

// --- Idle reasons ------------------------------------------------------------

// The answer to "it's running, why isn't it doing anything?". Kept out of the
// components so the deck and the lane say the same sentence.
export function idleReasonText(
  reason: AutoRunnerIdleReason | null,
  kind: AutoQueueKind,
): string | null {
  // "auto-transcribe" / "auto-download" for the two bucket lanes; the operation
  // lanes' runners are named for the lane itself ("auto-digest").
  const what = kind === "transcription" ? "transcribe" : kind;
  switch (reason) {
    case "no-pending":
      return "nothing pending — every rule is empty";
    case "capped":
      return "work exists, but every route to it is at a worker cap";
    case "cooldown":
      return "every pending platform is in a rate-limit cooldown";
    case "deferred":
      return "every pending video was rate-limited recently and is deferred";
    case "held":
      return "every pending platform is held after repeated rate limits — one probe at a time";
    case "paced":
      return "every pending platform is pausing between downloads";
    case "no-workers":
      return "no enabled worker to run it";
    case "workers-paused":
      return "transcriptions are paused";
    case "disk-gate":
      return "disk gate closed — not enough free space";
    case "downloads-paused":
      return "downloads are paused globally";
    case "snoozed":
      return "snoozed";
    case "disabled":
      return `auto-${what} was switched off`;
    case "lane-held":
      return "the lane is held — resume it to start dispatching again";
    case "engine-unreachable":
      return "the lane's engine did not answer its probe — check the job log";
    case "stopped":
    case null:
      return null;
  }
}

// --- Formatting --------------------------------------------------------------

export function formatClock(ms: number): string {
  if (!ms) return "—";
  return new Date(ms).toLocaleTimeString([], {
    hour: "2-digit",
    minute: "2-digit",
  });
}

// Compact elapsed time: 42s, 3m21s, 14m, 2h06m. Used for uptime and per-unit
// age, where a full duration string would swamp the line it sits on.
// Moved to lib/formatElapsed.ts, where the job row reads it too.
export { formatElapsed } from "../../lib/formatElapsed";

// A recency key as a date, marked when it was estimated rather than read.
export function formatRecency(
  key: { key: string; estimated: boolean } | undefined,
): string | null {
  if (!key || !key.key) return null;
  // The "newer than anything we know" sentinel — there is no date to show.
  if (!/^\d{8}$/.test(key.key)) return key.estimated ? "≈ newest" : null;
  const iso = `${key.key.slice(0, 4)}-${key.key.slice(4, 6)}-${key.key.slice(6)}`;
  return key.estimated ? `≈${iso}` : iso;
}

// A remaining cooldown: 42s, 3m 21s, 5h 59m. The hours arm is for a 6 h video
// deferral, which would otherwise read "359m 58s"; past an hour the seconds
// are noise and are dropped.
export function formatCooldown(secs: number): string {
  if (secs < 60) return `${secs}s`;
  // The days arm is for a subtitle hold (7 days), release 17.
  if (secs >= 86400) {
    const d = Math.floor(secs / 86400);
    const h = Math.floor((secs % 86400) / 3600);
    return h === 0 ? `${d}d` : `${d}d ${h}h`;
  }
  if (secs >= 3600) {
    const h = Math.floor(secs / 3600);
    const m = Math.floor((secs % 3600) / 60);
    return m === 0 ? `${h}h` : `${h}h ${m}m`;
  }
  const m = Math.floor(secs / 60);
  const s = secs % 60;
  return s === 0 ? `${m}m` : `${m}m ${s}s`;
}

// Snooze presets, resolved at click time so "until tomorrow" means the next
// local 09:00 rather than a fixed offset.
export function snoozePresets(now: number): { label: string; until: number }[] {
  const tomorrow = new Date(now);
  tomorrow.setDate(tomorrow.getDate() + 1);
  tomorrow.setHours(9, 0, 0, 0);
  return [
    { label: "1 hour", until: now + 3_600_000 },
    { label: "4 hours", until: now + 4 * 3_600_000 },
    { label: "Until tomorrow", until: tomorrow.getTime() },
  ];
}

// --- Control classes ---------------------------------------------------------

// The policy controls stay NATIVE <select> / <input type=checkbox> rather than
// the kit's Radix wrappers, and that is a deliberate, load-bearing choice:
// * `selectOption("alpha")` in the suite requires a real <select>;
// * `getByRole("option", { name: "downloadedAutoSubsOnly" })` must find exactly
//   one option page-wide — Radix's items are portalled and unmounted while the
//   menu is closed, so that count would be zero;
// * `getByLabel(/Enable auto-transcribe/).check()` is unambiguous on a real
//   checkbox input.
// They are token-styled to sit with the rest of the kit, so only the mechanism
// differs, not the look.
export const SELECT_CLASS =
  "rounded border border-border bg-background px-2 py-1 text-sm text-foreground";
export const NUM_CLASS =
  "rounded border border-border bg-background px-2 py-1 text-sm text-foreground tabular-nums";