"use client";

import { useActionState } from "react";
import type { SiteSettings } from "yt-dlp-transcript-common/lib/settings";
import { Field, SeededSelect } from "../../../components/forms/Field";
import { seedChecked } from "../../../lib/formState";
import { saveDiarizationSettingsAction } from "../../settingsActions";
import type { SaveResult } from "../../../settings/actions";

// The `diarization` block of settings.json, on /operations/diarization.
// Moved off /settings by slice 3. Legend and field names verbatim.
export function DiarizationSettingsForm({
  initial,
}: {
  initial: SiteSettings["diarization"];
}) {
  const [state, formAction, pending] = useActionState<
    SaveResult | undefined,
    FormData
  >(saveDiarizationSettingsAction, undefined);

  return (
    <form
      action={formAction}
      data-settings-block="diarization"
      className="flex flex-col gap-3"
    >
      <fieldset className="flex flex-col gap-3 border border-border rounded p-3">
        <legend className="px-1 text-sm font-medium">Diarization</legend>
        <p className="text-xs text-muted-foreground">
          Who is speaking when, captured to <code>diarization.json</code> beside
          each transcript. This runs on <strong>audio</strong>, and audio is the
          one input here that goes away — the Clean-audio sweep deletes it once a
          video is transcribed. So this is a one-shot window per video: the
          speaker turns can be captured now or not at all, while everything built
          on top of them can be redone from the saved file at any time.
        </p>
        <label className="flex items-start gap-2 text-sm">
          <input
            type="checkbox"
            name="diarizationEnabled"
            defaultChecked={seedChecked(
              state,
              "diarizationEnabled",
              initial.enabled,
            )}
            className="mt-1"
          />
          <span className="flex flex-col gap-1">
            <span className="font-medium">Capture speaker diarization</span>
            <span className="text-xs text-muted-foreground">
              Turning this on also <strong>holds disk</strong>: the Clean-audio
              sweep stops deleting audio for a transcribed video until its
              sidecar exists, and each channel&apos;s &quot;Est. reclaim&quot;
              drops to match. That hold is the point — it is what keeps the
              perishable input alive long enough to capture — but it means free
              space stops being reclaimed until diarization catches up.
            </span>
          </span>
        </label>
        <label className="flex items-start gap-2 text-sm">
          <input
            type="checkbox"
            name="diarizationInlineAfterTranscribe"
            defaultChecked={seedChecked(
              state,
              "diarizationInlineAfterTranscribe",
              initial.inlineAfterTranscribe,
            )}
            className="mt-1"
          />
          <span className="flex flex-col gap-1">
            <span className="font-medium">
              Diarize inline, right after each transcription
            </span>
            <span className="text-xs text-muted-foreground">
              Off by default, from measurement rather than caution. On this box
              transcription runs at ~221 s per audio-hour on the GPU (16× real
              time, over 3,602 videos); diarization runs on the CPU at roughly
              500–680, because no diarization model has been ported to ggml and
              neither ONNX nor PyTorch has a Vulkan path on Linux. Inline
              therefore makes the whole pipeline ~3–4× slower and idles the GPU.
              For a large batch, leave this off, let transcription run at full
              speed with the box above holding the audio, and catch up
              afterwards with <strong>Diarize speakers</strong> on each channel.
              Turn it on for steady state.
            </span>
          </span>
        </label>
        <label className="flex flex-col gap-1 text-sm">
          <span className="font-medium">Engine</span>
          <SeededSelect
            state={state}
            name="diarizationEngine"
            initial={initial.engine}
            className="rounded border border-border bg-card px-2 py-1 text-sm"
          >
            <option value="sherpa-onnx">
              sherpa-onnx — clustered, CPU only (default)
            </option>
            <option value="sortformer">
              Sortformer — end-to-end, GPU or CPU
            </option>
          </SeededSelect>
          <span className="text-xs text-muted-foreground">
            <strong>sherpa-onnx</strong> groups voices that sound alike, and it
            splits far too eagerly: on a 13-minute video with one host it finds
            13 speakers, and on the worst file in this corpus it finds 35.{" "}
            <strong>Sortformer</strong> decides turns directly instead of
            grouping them afterwards and returns 4 in both cases, agreeing with
            the other engine about how much of the video the main speaker talks
            for. It has no threshold, and it caps at 4 speakers — a panel of
            five will merge two rather than invent twenty.
            <br />
            <br />
            sherpa-onnx is the <strong>faster</strong> of the two (492 against
            894 seconds per audio-hour here), so this is a quality choice, not a
            speed one. Switching also{" "}
            <strong>marks every recording captured by the other engine as work
            to redo</strong>, because the two disagree about how many speakers
            exist — on the audio still held here that is weeks of it.
          </span>
        </label>
        <label className="flex flex-col gap-1 text-sm">
          <span className="font-medium">Sortformer device</span>
          <SeededSelect
            state={state}
            name="diarizationBackend"
            initial={initial.backend}
            className="rounded border border-border bg-card px-2 py-1 text-sm"
          >
            <option value="vulkan">Vulkan — the graphics card</option>
            <option value="cpu">CPU</option>
          </SeededSelect>
          <span className="text-xs text-muted-foreground">
            Ignored unless the engine above is Sortformer. Both produce{" "}
            <strong>identical</strong> speaker turns, so this only trades one
            resource for another: the card is ~1.5× faster and uses one core
            instead of two, but takes about 4.4 GB of the same 8 GB card
            transcription uses — so capture stands aside while transcription is
            working, and resumes when the card is free. On CPU it needs 4.84 GB
            of system memory instead.
          </span>
        </label>
        <Field
          label="Sortformer engine binary"
          name="diarizationSortformerBin"
          state={state}
          defaultValue={initial.sortformerBin}
          hint="Absolute path to the diarize-file binary built by scripts/build-sortformer.sh. Empty means the Sortformer engine is not configured, and every run reports a skip rather than a failure."
        />
        <Field
          label="Sortformer model (GGUF)"
          name="diarizationSortformerModel"
          state={state}
          defaultValue={initial.sortformerModel}
          hint="Absolute path to the .gguf downloaded by scripts/build-sortformer.sh. Its filename is recorded in every sidecar, so changing the model is what marks earlier captures worth redoing."
        />
        <Field
          label="Segmentation model (ONNX)"
          name="diarizationSegModel"
          state={state}
          defaultValue={initial.segModel}
          hint="Absolute path to a pyannote segmentation-3.0 ONNX model. Empty means the lane is not configured and every run reports a skip rather than a failure."
        />
        <Field
          label="Speaker-embedding model (ONNX)"
          name="diarizationEmbModel"
          state={state}
          defaultValue={initial.embModel}
          hint="Absolute path to a speaker-embedding ONNX model (e.g. NeMo TitaNet)."
        />
        <Field
          label="Python interpreter"
          name="diarizationPython"
          state={state}
          defaultValue={initial.python}
          hint="Interpreter with sherpa-onnx installed. sherpa-onnx ships wheels only up to CPython 3.13, so on a 3.14 system this must point at a dedicated venv."
        />
        <Field
          label="Clustering threshold"
          name="diarizationThreshold"
          state={state}
          defaultValue={String(initial.threshold)}
          type="number"
          step="0.01"
          hint="The knob that decides how many speakers come out; larger merges more. It is recorded in every sidecar, so changing it is what lets a later pass tell which files are worth regenerating."
        />
        <Field
          label="Engine threads"
          name="diarizationThreads"
          state={state}
          defaultValue={String(initial.threads)}
          type="number"
          hint="Threads per diarize run."
        />
        <Field
          label="Max audio hours"
          name="diarizationMaxAudioHours"
          state={state}
          defaultValue={String(initial.maxAudioHours)}
          type="number"
          step="0.5"
          hint="Videos longer than this are reported as deferred instead of being diarized, and are never counted as work still to do. This is a stopgap for an out-of-memory crash on very long recordings: the engine's memory use grows with the SQUARE of the number of speaker turns, so a dense six-hour stream can exhaust 16 GB after 40 minutes of work and produce nothing. 0 turns the limit off."
        />
        <Field
          label="Diarization concurrency"
          name="diarizationConcurrency"
          state={state}
          defaultValue={String(initial.concurrency)}
          type="number"
          hint="Videos diarized at once during a backfill. Default 1: this is CPU-bound work competing with GPU feeding and the digest sweep for the same 8 threads."
        />
        <div className="flex items-center gap-3">
          <button
            type="submit"
            disabled={pending}
            className="px-3 py-1.5 rounded-md bg-primary text-primary-foreground text-sm font-medium hover:opacity-90 disabled:opacity-50"
          >
            {pending ? "Saving…" : "Save diarization settings"}
          </button>
          {state?.ok === true && (
            <span role="status" className="text-sm text-success">
              Saved.
            </span>
          )}
          {state?.ok === false && (
            <span role="alert" className="text-sm text-destructive">
              {state.error}
            </span>
          )}
        </div>
      </fieldset>
    </form>
  );
}