"use client";

// THE ASSEMBLY, not the cards. Each chore card's body — its state, its server
// action, its copy — is its own module under ./cards/ (enumerated, with why each
// is a chore and not an operation, in ../lib/videoChoreCards.ts). What stays here
// is what only the page as a whole knows: the ORDER of the cards and the gating
// booleans derived from the file list, the download outcome and the coverage.
// The registry-driven operation panels (digest, diarization, attribution) render
// after this component, in page.tsx.

import type {
  AudioFormat,
  ChannelHandling,
} from "yt-dlp-transcript-common/lib/channelConfig";
import type { DownloadOutcomeRecord } from "yt-dlp-transcript-common/lib/downloadOutcome";
import type { SavedVideoPointer } from "yt-dlp-transcript-common/lib/savedVideo";
import type { SourceVideoQuality } from "yt-dlp-transcript-common/ytdlp/downloadFormat";
import type { AvailabilityHistoryEntry } from "yt-dlp-transcript-common/lib/availability";
import type { SubtitleProvenance } from "yt-dlp-transcript-common/lib/subtitleProvenance";
import { formatBytes } from "yt-dlp-transcript-common/lib/format";
import { PipelineStageCard } from "../../../components/PipelineStageCard";
import { TranscriptTracksReader } from "./cards/TranscriptTracksReader";
import { VideoNavStrip } from "./VideoNavStrip";
import { PipelineStatusStrip } from "./PipelineStatusStrip";
import { AvailabilityHistoryList } from "./cards/AvailabilityHistoryList";
import { DeleteVideoDirSection } from "./cards/DeleteVideoDirSection";
import { DoNotCleanSection } from "./cards/DoNotCleanSection";
import { DownloadOutcomeBadge } from "./cards/DownloadOutcomeBadge";
import { ExcludeTruncatedCheckSection } from "./cards/ExcludeTruncatedCheckSection";
import { FetchedWindows, type FetchedWindow } from "./cards/FetchedWindows";
import { FilesList } from "./cards/FilesList";
import { IncompleteTranscriptBanner } from "./cards/IncompleteTranscriptBanner";
import { MarkUntranscribableSection } from "./cards/MarkUntranscribableSection";
import { PerFileTranscodeRow } from "./cards/PerFileTranscodeRow";
import { PerFileTranscribeRow } from "./cards/PerFileTranscribeRow";
import { RedownloadSection } from "./cards/RedownloadSection";
import { ShortAudioBanner } from "./cards/ShortAudioBanner";
import { SourceVideoSection } from "./cards/SourceVideoSection";
import { TranscriptSourceSection } from "./cards/TranscriptSourceSection";
import { SubtitleDeferralLine } from "./SubtitleDeferralLine";
import {
  CANONICAL_VTT,
  WHISPER_FILENAME,
  isAudioFile,
  isTranscodeSource,
  isTranscriptVttName,
  type VideoFile,
} from "./cards/videoFiles";

// Both pages import these types from here; they are defined beside the cards
// that use them.
export type { FetchedWindow, VideoFile };

type Props = {
  slug: string;
  videoId: string;
  files: VideoFile[];
  // Resolved primary English VTT filename (transcript.en.vtt, or a regional/auto
  // fallback like transcript.en-US.vtt), or null when no English VTT exists.
  primaryVtt: string | null;
  // filename -> where that subtitle track came from (YouTube ASR vs a manual
  // upload). Computed server-side from a 4 KB head read per VTT.
  vttProvenance?: Record<string, SubtitleProvenance>;
  handling: ChannelHandling;
  defaultQueueKey: string;
  existingQueues: string[];
  downloadOutcome: DownloadOutcomeRecord | null;
  availabilityHistory: AvailabilityHistoryEntry[];
  channelAudioFormat?: AudioFormat;
  doNotClean?: boolean;
  // When true the user has opted this video out of the truncated/incomplete
  // check, so the "looks truncated" banner is suppressed and the toggle reads
  // as on. Drives ExcludeTruncatedCheckSection.
  excludedFromTruncatedCheck?: boolean;
  // This video's saved-video pointer when its source container is persisted to
  // the store, else null. Drives the Source-video persistence card (Phase 5).
  savedVideo?: SavedVideoPointer | null;
  // The effective source-video quality for this channel (channel over global,
  // resolveSourceVideoQuality): where the persist control's select starts.
  sourceVideoQuality?: SourceVideoQuality;
  // Windows of this video's source media another tool asked the editor to
  // fetch, into data/<id>/clips/. Empty for almost every video.
  clipWindows?: FetchedWindow[];
  // Transcript coverage vs. video duration. When `incomplete` the transcript
  // covers only a fraction of the runtime (truncated audio download) — surfaced
  // as a warning banner with a re-download/re-transcribe action. Absent when
  // there's no transcript or no duration to judge against.
  coverage?: {
    lastCueEnd: number;
    duration: number;
    coverage: number | null;
    incomplete: boolean;
  } | null;
  prevHref?: string;
  nextHref?: string;
  position?: { index: number; total: number };
  // The umtool front door, when UMTOOL_URL is set on the editor. One link:
  // "open in umtool" scaffolds a report video from this exact video.
  umtoolUrl?: string | null;
};

export function VideoPanel({
  slug,
  videoId,
  files,
  primaryVtt,
  handling,
  defaultQueueKey,
  existingQueues,
  downloadOutcome,
  availabilityHistory,
  channelAudioFormat,
  doNotClean = false,
  excludedFromTruncatedCheck = false,
  savedVideo = null,
  sourceVideoQuality,
  clipWindows = [],
  coverage = null,
  prevHref,
  nextHref,
  position,
  vttProvenance = {},
  umtoolUrl = null,
}: Props) {
  const audioFiles = files.filter((f) => isAudioFile(f.name));
  const transcodeSources = files.filter((f) => isTranscodeSource(f.name));
  const hasTranscriptJson = files.some((f) => f.name === WHISPER_FILENAME);
  const hasYtVtt = primaryVtt !== null;
  const hasTranscript = hasTranscriptJson || hasYtVtt;
  // This video's only transcript is YouTube's speech recognition: the transcribe
  // controls stay live so it can be replaced with one of our own. A manual — or
  // unclassifiable — caption track still blocks them.
  const autoSubsOnly =
    !hasTranscriptJson &&
    primaryVtt !== null &&
    vttProvenance[primaryVtt] === "asr";
  const vttTracks = files
    .filter((f) => isTranscriptVttName(f.name))
    .map((f) => f.name)
    .sort();
  // The transcript the index/viewer will actually use: whisper wins over VTT.
  const activeTranscript = hasTranscriptJson ? WHISPER_FILENAME : primaryVtt;
  const noAudio = audioFiles.length === 0;
  const downloadFailed = downloadOutcome?.status === "failed";
  const incompleteTranscript = coverage?.incomplete ?? false;

  const downloadSummary = noAudio
    ? handling === "youtube"
      ? "No audio on disk — run the pipeline (VTT first, whisper if needed)."
      : "Audio not yet downloaded."
    : `${audioFiles.length} audio file${audioFiles.length === 1 ? "" : "s"} on disk.`;
  const transcribeSummary = autoSubsOnly
    ? "YouTube auto-captions only — can be replaced with an AI transcript."
    : hasTranscript
      ? "Transcript present."
      : noAudio
        ? "No audio yet — run the download pipeline (or use Audio + Whisper) to produce a transcript."
        : "Audio ready, no transcript.";
  const transcodeSummary =
    transcodeSources.length > 0
      ? `Convert ${transcodeSources.length} source file${transcodeSources.length === 1 ? "" : "s"} to another format.`
      : "Nothing to transcode.";

  const showNav = !!prevHref || !!nextHref || !!position;

  return (
    <div className="flex flex-col gap-4">
      {showNav && (
        <VideoNavStrip
          prevHref={prevHref}
          nextHref={nextHref}
          position={position}
          videoId={videoId}
        />
      )}
      {umtoolUrl && (
        <div className="text-sm">
          <a
            href={`${umtoolUrl}/?from=${encodeURIComponent(`${slug}/${videoId}`)}`}
            className="underline"
            data-umtool-link
          >
            Open in umtool
          </a>
          <span className="text-muted-foreground"> — start a report video from this recording</span>
        </div>
      )}
      <PipelineStatusStrip
        downloaded={!noAudio}
        transcribed={hasTranscript}
        downloadFailed={downloadFailed}
      />
      {downloadOutcome && <DownloadOutcomeBadge outcome={downloadOutcome} />}
      {/* BOTH BANNERS ARE RENDERED UNCONDITIONALLY, and each decides for
          itself whether to draw anything. THE RULE (plans/FACTS.md, fae99f1):
          a component carrying a StreamActionLog must not be UNMOUNTED when the
          record its own run produced lands. Each of these banners runs the very
          operation that CLEARS the condition that drew it, and StreamActionLog
          fires router.refresh() itself the moment its run ends — so a parent
          that stops rendering the banner on that refresh destroys the log the
          operator is reading, the <pre role="log"> and all, at the instant the
          run's last line arrives. Passing the condition down instead of
          branching on it here keeps the banner's fiber (and its log) alive
          across that refresh; with no run and the condition false the banner
          renders null, so the DOM is unchanged. */}
      <IncompleteTranscriptBanner
        slug={slug}
        videoId={videoId}
        coverage={incompleteTranscript ? coverage : null}
        defaultQueueKey={defaultQueueKey}
        existingQueues={existingQueues}
      />
      <ShortAudioBanner
        slug={slug}
        videoId={videoId}
        flagged={
          downloadOutcome?.status === "failed-short-audio" &&
          !excludedFromTruncatedCheck
        }
        shortAudio={downloadOutcome?.shortAudio}
        defaultQueueKey={defaultQueueKey}
        existingQueues={existingQueues}
      />
      <PipelineStageCard
        id="availability-history"
        title="Availability history"
        summary={
          availabilityHistory.length === 0
            ? "No availability changes recorded."
            : `${availabilityHistory.length} recorded change${availabilityHistory.length === 1 ? "" : "s"}.`
        }
        defaultOpen={false}
        tone="neutral"
      >
        <AvailabilityHistoryList entries={availabilityHistory} />
      </PipelineStageCard>
      {doNotClean && (
        <div
          role="status"
          aria-label="media archived"
          className="rounded border px-3 py-2 text-sm border-info/30 bg-info-soft text-info"
        >
          Media archived — cleanup will skip this video.
        </div>
      )}
      <PipelineStageCard
        id="download"
        title={noAudio ? "Download audio" : "Redownload audio"}
        summary={downloadSummary}
        defaultOpen={true}
        tone={
          noAudio
            ? "attention"
            : downloadFailed
              ? "danger"
              : incompleteTranscript
                ? "attention"
                : "neutral"
        }
      >
        <RedownloadSection
          slug={slug}
          videoId={videoId}
          handling={handling}
          defaultQueueKey={defaultQueueKey}
          existingQueues={existingQueues}
          noAudio={noAudio}
        />
      </PipelineStageCard>

      {transcodeSources.length > 0 && (
        <PipelineStageCard
          id="transcode"
          title="Transcode"
          summary={transcodeSummary}
          defaultOpen={true}
          tone="neutral"
        >
          <div className="flex flex-col gap-4">
            {transcodeSources.map((f) => (
              <PerFileTranscodeRow
                key={f.name}
                slug={slug}
                videoId={videoId}
                file={f}
                existingQueues={existingQueues}
                channelAudioFormat={channelAudioFormat}
              />
            ))}
          </div>
        </PipelineStageCard>
      )}

      <PipelineStageCard
        id="transcribe"
        title="Transcribe"
        summary={transcribeSummary}
        defaultOpen={true}
        tone={
          incompleteTranscript
            ? "attention"
            : hasTranscript
              ? "ok"
              : noAudio
                ? "neutral"
                : "attention"
        }
      >
        <div className="flex flex-col gap-4">
          {audioFiles.map((f) => (
            <PerFileTranscribeRow
              key={f.name}
              slug={slug}
              videoId={videoId}
              file={f}
              existingQueues={existingQueues}
              hasTranscript={hasTranscript && !autoSubsOnly}
              replaceAutoSubs={autoSubsOnly}
            />
          ))}
        </div>
      </PipelineStageCard>

      <SubtitleDeferralLine slug={slug} videoId={videoId} />

      {hasTranscript && (
        <PipelineStageCard
          id="transcript-read"
          title="Transcript"
          summary={
            vttTracks.length + (hasTranscriptJson ? 1 : 0) > 1
              ? "Read it; switch to another track where one says something else."
              : "Read it."
          }
          defaultOpen={false}
          tone="neutral"
        >
          <TranscriptTracksReader slug={slug} videoId={videoId} />
        </PipelineStageCard>
      )}

      {vttTracks.length > 0 && (
        <PipelineStageCard
          id="transcript-source"
          title="Transcript source"
          summary={
            activeTranscript
              ? `Primary transcript: ${activeTranscript}`
              : "No primary transcript selected."
          }
          defaultOpen={vttTracks.length > 1 || primaryVtt !== CANONICAL_VTT}
          tone={
            primaryVtt && primaryVtt !== CANONICAL_VTT && !hasTranscriptJson
              ? "attention"
              : "neutral"
          }
        >
          <TranscriptSourceSection
            slug={slug}
            videoId={videoId}
            vttTracks={vttTracks}
            primaryVtt={primaryVtt}
            hasWhisper={hasTranscriptJson}
            vttProvenance={vttProvenance}
          />
        </PipelineStageCard>
      )}

      {!hasTranscript && (
        <PipelineStageCard
          id="mark-untranscribable"
          title="Mark untranscribable"
          summary="Stop the pipeline from retrying this video."
          defaultOpen={true}
          tone="neutral"
        >
          <MarkUntranscribableSection slug={slug} videoId={videoId} />
        </PipelineStageCard>
      )}

      <PipelineStageCard
        id="source-video-persistence"
        title="Source video"
        summary={
          savedVideo
            ? `Persisted to the saved-video store (${formatBytes(savedVideo.bytes)}).`
            : "Persist the source video to the saved-video store."
        }
        defaultOpen={!!savedVideo}
        tone={savedVideo ? "ok" : "neutral"}
      >
        <SourceVideoSection
          slug={slug}
          videoId={videoId}
          handling={handling}
          defaultQueueKey={defaultQueueKey}
          existingQueues={existingQueues}
          savedVideo={savedVideo}
          defaultQuality={sourceVideoQuality}
        />
      </PipelineStageCard>

      {clipWindows.length > 0 && (
        <PipelineStageCard
          id="fetched-windows"
          title="Fetched windows"
          // THE BYTES ARE IN THE SUMMARY, not only inside the card. A window is
          // seconds of media, but nothing prunes one — the retention sweep is
          // pointer-driven and never sees a `clips/` file — so a video walked
          // by many reports accumulates them silently. The total is free here:
          // every window in the list already carries its own `bytes`.
          summary={`${clipWindows.length} window${
            clipWindows.length === 1 ? "" : "s"
          } (${formatBytes(
            clipWindows.reduce((n, w) => n + w.bytes, 0),
          )}) of this video's source media, fetched for another tool.`}
          defaultOpen={false}
          tone="neutral"
        >
          <FetchedWindows windows={clipWindows} />
        </PipelineStageCard>
      )}

      <PipelineStageCard
        id="archive-media"
        title="Archive media"
        summary={
          doNotClean
            ? "Protected — cleanup will skip this video."
            : "Exclude this video's media from cleanup jobs."
        }
        defaultOpen={true}
        tone={doNotClean ? "ok" : "neutral"}
      >
        <DoNotCleanSection
          slug={slug}
          videoId={videoId}
          doNotClean={doNotClean}
        />
      </PipelineStageCard>

      <PipelineStageCard
        id="truncated-check"
        title="Truncated check"
        summary={
          excludedFromTruncatedCheck
            ? "Excluded — this video won't be flagged as truncated."
            : "Exclude this video from the truncated-transcript check."
        }
        defaultOpen={false}
        tone={excludedFromTruncatedCheck ? "ok" : "neutral"}
      >
        <ExcludeTruncatedCheckSection
          slug={slug}
          videoId={videoId}
          excluded={excludedFromTruncatedCheck}
        />
      </PipelineStageCard>

      <PipelineStageCard
        id="files"
        title="Files"
        summary={`${files.length} file${files.length === 1 ? "" : "s"} in this directory.`}
        defaultOpen={true}
        tone="neutral"
      >
        <FilesList slug={slug} videoId={videoId} files={files} />
      </PipelineStageCard>

      <PipelineStageCard
        id="danger"
        title="Danger zone"
        summary={`Delete data/${videoId}/`}
        defaultOpen={true}
        tone="neutral"
      >
        <DeleteVideoDirSection slug={slug} videoId={videoId} />
      </PipelineStageCard>
    </div>
  );
}