// Peach Codex — restoration view.
//
// Two entry paths, both feeding the same ChunkBuffer:
//   • Camera scan — Aztec codes via @zxing/library
//   • PDF import — pdf.js + grid scan of each rendered page
//
// Once ChunkBuffer.isReady():
//   1. Prompt for the master passphrase.
//   2. Reconstruct + integrity-verify locally (popup) via reconstructAndVerify.
//   3. Hand the payload to the SW (RESTORE_FROM_CODEX) for actual decrypt
//      and replace.
//
// Restoration is intentionally NOT Pro-gated — a printed Codex must remain
// restorable forever, regardless of license state.

import { createSignal, onCleanup, onMount, Show } from "solid-js";
import { sendMessage } from "../../shared/bridge";
import {
  ChunkBuffer,
  createScanGate,
  parseRawScan,
  reconstructAndVerify,
} from "../codex/restore";
import { startScanner } from "../codex/scanner";
import type { ScannerHandle } from "../codex/scanner";
import type { CodexPayload } from "../../shared/codex-types";

interface CodexRestoreViewProps {
  onBack: () => void;
  onRestoreSuccess: () => void;
}

type Phase =
  | "choose"
  | "scanning"
  | "pdf-import"
  | "pdf-shortfall"
  | "ready"
  | "restoring"
  | "success"
  | "error";

export function CodexRestoreView(props: CodexRestoreViewProps) {
  // The buffer is intentionally not stored in a signal — its identity is
  // stable across the lifetime of the view and we read it through the
  // `size()`/`isReady()` methods. We mirror its observable state into
  // signals so Solid can re-render.
  const buffer = new ChunkBuffer();
  let videoEl: HTMLVideoElement | undefined;
  let scanner: ScannerHandle | null = null;
  let pdfFileInput: HTMLInputElement | undefined;

  const [phase, setPhase] = createSignal<Phase>("choose");
  const [scanned, setScanned] = createSignal(0);
  const [dataShards, setDataShards] = createSignal<number | null>(null);
  const [verifyCode, setVerifyCode] = createSignal<string | null>(null);
  const [hint, setHint] = createSignal(
    "point your camera at the first code on page 1",
  );
  const [cameraError, setCameraError] = createSignal<string | null>(null);
  const [scanWarning, setScanWarning] = createSignal<string | null>(null);
  const [pdfProgress, setPdfProgress] = createSignal<{
    page: number;
    total: number;
  } | null>(null);
  const [pdfError, setPdfError] = createSignal<string | null>(null);
  const [pdfShortfall, setPdfShortfall] = createSignal<{
    found: number;
    missing: number;
    ready: number;
    total: number;
  } | null>(null);
  // Hold the reconstructed payload between the integrity check and the SW
  // call so the user can re-enter the passphrase on a wrong-password failure
  // without rescanning every code.
  const [pendingPayload, setPendingPayload] = createSignal<CodexPayload | null>(
    null,
  );
  const [passphrase, setPassphrase] = createSignal("");
  const [restoreError, setRestoreError] = createSignal<string | null>(null);
  const [restoredCount, setRestoredCount] = createSignal<number | null>(null);

  function refreshFromBuffer() {
    setScanned(buffer.size());
    const ctx = buffer.getContext();
    if (ctx) {
      setDataShards(ctx.dataShards);
      setVerifyCode(ctx.verifyCode);
    }
    if (
      buffer.isReady() &&
      (phase() === "scanning" || phase() === "pdf-import" || phase() === "pdf-shortfall")
    ) {
      setPhase("ready");
      setHint("scan complete. enter your master password to restore.");
      setPdfShortfall(null);
      // Stop the camera the instant we have enough codes — no reason to keep
      // the green light on while the user types their passphrase.
      if (scanner) {
        scanner.stop();
        scanner = null;
      }
    } else if (phase() === "scanning") {
      const ds = ctx?.dataShards;
      if (ds) {
        const remaining = Math.max(ds - buffer.size(), 0);
        setHint(
          remaining > 0
            ? `${remaining} more ${remaining === 1 ? "code" : "codes"} needed`
            : "almost there…",
        );
      }
    }
  }

  function explainScanReason(reason: string): string {
    switch (reason) {
      case "foreign_codex":
        return "that code belongs to a different Codex.";
      case "bad_integrity":
        return "a code's checksum failed — try again.";
      case "duplicate":
        return ""; // not surfaced — duplicates are normal as the user pans
      case "parse_error":
        return "could not read that code.";
      default:
        return "";
    }
  }

  async function handleScan(raw: string) {
    const parsed = parseRawScan(raw);
    if ("error" in parsed) {
      // parseRawScan failures are usually a non-Peach Aztec code or a corrupt
      // frame; quietly ignore so the scanner keeps running.
      return;
    }

    const result = await buffer.add(parsed);
    refreshFromBuffer();
    if (!result.accepted && result.reason) {
      const msg = explainScanReason(result.reason);
      if (msg) {
        setScanWarning(msg);
        // Auto-clear so the warning doesn't linger after the user moves on.
        setTimeout(() => setScanWarning(null), 2500);
      }
    }
  }

  function handleScannerError(err: Error) {
    setCameraError(
      err.name === "NotAllowedError"
        ? "camera access was denied. allow camera permission and reopen this screen."
        : err.message || "camera failed to start.",
    );
  }

  async function startCameraScan() {
    setPhase("scanning");
    setCameraError(null);
    setPdfShortfall(null);
    // Solid hasn't rendered the <video> element yet — defer until next tick.
    await Promise.resolve();
    if (!videoEl) return;
    try {
      // PB-26-207: the decoder fires per frame — gate to one parse/add in
      // flight, dropping repeats while busy instead of queueing work.
      const gate = createScanGate((text) => handleScan(text));
      scanner = await startScanner({
        videoEl,
        onScan: (text) => gate.onScan(text),
        onError: (err) => handleScannerError(err),
      });
    } catch (err) {
      handleScannerError(err instanceof Error ? err : new Error(String(err)));
    }
  }

  // The Chrome action popup dismisses the moment the OS file picker steals
  // focus, which stranded users mid-import. From the popup we instead open
  // the restore view in a standalone window and let that window own the file
  // dialog. The window is created by the service worker — a window the popup
  // creates itself gets cascade-closed when the popup dismisses. Within the
  // detached window (?codex=pdf), or any context without a runtime bridge,
  // we trigger the input directly.
  async function openPdfPicker() {
    if (autoPickPdf) {
      pdfFileInput?.click();
      return;
    }
    if (typeof chrome === "undefined" || typeof chrome.runtime?.sendMessage !== "function") {
      pdfFileInput?.click();
      return;
    }
    try {
      // The standalone window is opened by the service worker: a window the
      // popup creates itself is cascade-closed by Chrome when the popup
      // dismisses, which stranded users mid-import.
      const res = (await sendMessage({
        type: "OPEN_DETACHED_POPUP",
        payload: { route: "codex-pdf" },
      })) as { ok: boolean; data?: { detached?: boolean } };
      if (!res?.data?.detached) {
        pdfFileInput?.click();
        return;
      }
      // The action popup dismisses itself when the new window steals focus —
      // calling window.close() here cascade-closes the detached child too.
    } catch (err) {
      console.warn("[codex] failed to detach popup for PDF import:", err);
      pdfFileInput?.click();
    }
  }

  async function handlePDFSelected(e: Event) {
    const input = e.currentTarget as HTMLInputElement;
    const file = input.files?.[0];
    // Reset the input so the same file can be re-selected after an error.
    input.value = "";
    if (!file) return;

    if (!file.type.includes("pdf") && !file.name.toLowerCase().endsWith(".pdf")) {
      setPdfError("please select a Peach Codex PDF file.");
      return;
    }

    setPhase("pdf-import");
    setPdfProgress(null);
    setPdfError(null);
    setPdfShortfall(null);

    try {
      // Dynamic import so the popup never pulls pdf.js into the camera-only
      // path — keeps the initial bundle small.
      const { importCodexPDF } = await import("../codex/pdf-import");
      const result = await importCodexPDF(file, (page, total) => {
        setPdfProgress({ page, total });
      });

      if (result.envelopes.length === 0) {
        // A size/parse rejection lands here with the real reason in errors[];
        // showing the generic "no codes" message for it is what made an
        // oversized Codex read as a broken importer.
        setPdfError(
          result.errors.length > 0
            ? result.errors[0]!
            : "no Codex codes found in this PDF. make sure you're selecting a Peach Codex PDF, not a different document.",
        );
        setPhase("choose");
        return;
      }

      for (const envelope of result.envelopes) {
        await buffer.add(envelope);
      }
      refreshFromBuffer();

      if (!buffer.isReady()) {
        const stripes = buffer.stripeReadiness();
        const ready = stripes.filter((s) => s.isReady).length;
        const missing = stripes.reduce(
          (sum, s) => sum + Math.max(0, s.required - s.found),
          0,
        );
        setPdfShortfall({
          found: buffer.size(),
          missing,
          ready,
          total: stripes.length,
        });
        setPhase("pdf-shortfall");
        return;
      }
    } catch (err) {
      setPdfError(
        `failed to read PDF: ${err instanceof Error ? err.message : String(err)}`,
      );
      setPhase("choose");
    }
  }

  function retryPdfImport() {
    setPdfShortfall(null);
    void openPdfPicker();
  }

  // Detect whether we are running inside a chrome.windows.create() window
  // that was opened specifically to handle the PDF picker. The action
  // popup dismisses on focus loss, so the file dialog tears it down. When
  // routed via ?codex=pdf we know we are in a survivable window and can
  // safely auto-trigger the picker on mount.
  const autoPickPdf = (() => {
    try {
      return new URLSearchParams(window.location.search).get("codex") === "pdf";
    } catch {
      return false;
    }
  })();

  onMount(() => {
    if (autoPickPdf) {
      // Tiny delay so the click happens after the SolidJS mount settles
      // and the hidden <input> is in the DOM.
      setTimeout(() => pdfFileInput?.click(), 50);
    }
  });

  onCleanup(() => {
    if (scanner) {
      scanner.stop();
      scanner = null;
    }
    // `scanner.stop()` calls reader.reset(), which tears down the
    // MediaStream attached to the <video> element. Defensive: clear srcObject
    // in case the library leaves a reference behind after reset (observed in
    // older @zxing/library versions).
    if (videoEl?.srcObject) {
      const stream = videoEl.srcObject as MediaStream;
      stream.getTracks().forEach((t) => t.stop());
      videoEl.srcObject = null;
    }
  });

  function explainRestoreError(error: string | undefined): string {
    if (!error) return "restoration failed. please try again.";
    if (error.includes("WRONG_PASSPHRASE") || error.includes("wrong"))
      return "wrong master password. try again.";
    if (error.includes("INVALID_VAULT_BLOB"))
      return "the reconstructed vault is unreadable. please re-scan the Codex.";
    if (error.includes("FINGERPRINT_MISMATCH"))
      return "vault integrity check failed. please re-scan the Codex.";
    // PB-26-607: never echo the raw background error into the UI.
    return "restoration failed. please try again.";
  }

  async function handleRestore() {
    if (phase() === "restoring") return;
    const pw = passphrase();
    // PCH-01-015: trim ONLY for the emptiness check — the raw passphrase must
    // reach RESTORE_FROM_CODEX so a master password with surrounding whitespace
    // (which unlocks fine on the lock screen, see Lock.tsx) also restores.
    if (!pw.trim()) {
      setRestoreError("enter your master password.");
      return;
    }

    setPhase("restoring");
    setRestoreError(null);

    let payload = pendingPayload();
    if (!payload) {
      try {
        payload = await reconstructAndVerify(buffer);
        setPendingPayload(payload);
      } catch (err) {
        const message =
          err instanceof Error
            ? err.message
            : "the scanned codes could not be reassembled.";
        setRestoreError(message);
        setPhase("ready");
        return;
      }
    }

    const res = (await sendMessage({
      type: "RESTORE_FROM_CODEX",
      payload: {
        vaultBlob: payload.vaultBlob,
        timestamp: payload.timestamp,
        verifyCode: payload.verifyCode,
        vaultFingerprint: payload.vaultFingerprint,
        entryCount: payload.entryCount,
        masterPassphrase: pw,
      },
    })) as {
      ok: boolean;
      data?: { entryCount: number; verifyCode: string };
      error?: string;
    };

    if (res.ok && res.data) {
      setRestoredCount(res.data.entryCount);
      setPhase("success");
      if (scanner) {
        scanner.stop();
        scanner = null;
      }
      setTimeout(() => props.onRestoreSuccess(), 1500);
    } else {
      setRestoreError(explainRestoreError(res.error));
      setPhase("ready");
    }
  }

  function progressPercent(): number {
    const stripes = buffer.stripeReadiness();
    if (stripes.length > 0) {
      const worst = stripes.reduce((min, s) => (s.found < min.found ? s : min), stripes[0]!);
      if (worst.required > 0) {
        return Math.min(100, Math.round((worst.found / worst.required) * 100));
      }
    }
    const ds = dataShards();
    if (!ds || ds <= 0) return 0;
    return Math.min(100, Math.round((scanned() / ds) * 100));
  }

  function stripeProgressSummary():
    | { ready: number; total: number; worstFound: number; worstRequired: number }
    | null {
    const stripes = buffer.stripeReadiness();
    if (stripes.length === 0) return null;
    const ready = stripes.filter((s) => s.isReady).length;
    const worst = stripes.reduce((min, s) => (s.found < min.found ? s : min), stripes[0]!);
    return {
      ready,
      total: stripes.length,
      worstFound: worst.found,
      worstRequired: worst.required,
    };
  }

  return (
    <div class="peach-overlay-view ov-enter-right" style="display:flex">
      <div class="peach-overlay-header">
        <button
          class="peach-btn peach-btn--ghost peach-btn--sm peach-icon-btn"
          onClick={props.onBack}
          aria-label="Back"
        >
          <svg width="7" height="12" viewBox="0 0 7 12" fill="none"
            stroke="currentColor" stroke-width="1.1"
            stroke-linecap="round" stroke-linejoin="round">
            <path d="M6 1L1 6L6 11" />
          </svg>
        </button>
        <span class="peach-overlay-title">restore from codex</span>
        <div class="peach-overlay-spacer"></div>
      </div>

      <div class="peach-settings-body peach-codex-body">
        <Show when={phase() === "choose"}>
          <div class="peach-codex-restore-choose">
            <h2 class="peach-codex-restore-headline">restore from codex.</h2>
            <p class="peach-codex-restore-sub">
              how do you have your codex?
            </p>

            <button
              class="peach-codex-restore-option"
              onClick={() => void startCameraScan()}
            >
              <div class="peach-codex-restore-option-icon">
                <svg width="22" height="22" viewBox="0 0 24 24" fill="none"
                  stroke="currentColor" stroke-width="1.5"
                  stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
                  <path d="M3 8a2 2 0 0 1 2-2h2l1.5-2h7L17 6h2a2 2 0 0 1 2 2v10a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2V8z" />
                  <circle cx="12" cy="13" r="3.5" />
                </svg>
              </div>
              <div class="peach-codex-restore-option-content">
                <span class="peach-codex-restore-option-title">
                  scan printed pages
                </span>
                <span class="peach-codex-restore-option-sub">
                  point your camera at each code
                </span>
              </div>
            </button>

            <button
              class="peach-codex-restore-option"
              onClick={() => void openPdfPicker()}
            >
              <div class="peach-codex-restore-option-icon">
                <svg width="22" height="22" viewBox="0 0 24 24" fill="none"
                  stroke="currentColor" stroke-width="1.5"
                  stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">
                  <path d="M14 3H7a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h10a2 2 0 0 0 2-2V8z" />
                  <path d="M14 3v5h5" />
                  <path d="M9 14h6" />
                  <path d="M9 17h4" />
                </svg>
              </div>
              <div class="peach-codex-restore-option-content">
                <span class="peach-codex-restore-option-title">
                  import PDF file
                </span>
                <span class="peach-codex-restore-option-sub">
                  select your codex PDF from a USB drive or folder
                </span>
              </div>
            </button>

            <p class="peach-codex-restore-guidance">
              have both the printed pages and the PDF? the PDF import is
              faster and more reliable — use it if you can.
            </p>

            <Show when={pdfError()}>
              <p class="peach-hint peach-hint-error peach-codex-restore-guidance">
                {pdfError()}
              </p>
            </Show>
          </div>
        </Show>

        <input
          ref={(el) => (pdfFileInput = el)}
          type="file"
          accept=".pdf,application/pdf"
          style={{ display: "none" }}
          onChange={(e) => void handlePDFSelected(e)}
        />

        <Show when={phase() === "pdf-shortfall"}>
          <div class="peach-settings-group peach-codex-pdf-shortfall">
            <p class="peach-codex-restore-headline">pdf import needs another pass.</p>
            <p class="peach-codex-pdf-shortfall-copy">
              The PDF decoded {pdfShortfall()?.found ?? 0} codes, but {pdfShortfall()?.missing ?? 0} remained unreadable.
              {pdfShortfall()?.ready === pdfShortfall()?.total
                ? " all stripes are ready now."
                : ` ${pdfShortfall()?.ready ?? 0} of ${pdfShortfall()?.total ?? 0} stripes are ready.`}
            </p>
            <p class="peach-codex-pdf-shortfall-copy">
              try importing the PDF again to fill the gaps, or switch to camera scanning if it keeps failing.
            </p>
            <div class="peach-codex-pdf-shortfall-actions">
              <button
                class="peach-btn peach-btn--accent peach-btn--md"
                onClick={() => retryPdfImport()}
              >
                try PDF again
              </button>
              <button
                class="peach-btn peach-btn--ghost peach-btn--md"
                onClick={() => void startCameraScan()}
              >
                use camera
              </button>
            </div>
          </div>
        </Show>

        <Show
          when={
            phase() === "scanning" ||
            phase() === "ready" ||
            phase() === "restoring"
          }
        >
          <div class="peach-codex-scanner">
            <video
              ref={(el) => (videoEl = el)}
              class="peach-codex-video"
              autoplay
              playsinline
              muted
            />
            <Show when={cameraError()}>
              <div class="peach-codex-camera-overlay">
                <p class="peach-hint peach-hint-error">{cameraError()}</p>
              </div>
            </Show>
          </div>
        </Show>

        <Show when={phase() === "pdf-import"}>
          <div class="peach-settings-group peach-codex-pdf-import">
            <p class="peach-codex-restore-headline">reading your codex…</p>
            <Show when={pdfProgress()}>
              {(p) => (
                <>
                  <div class="peach-codex-progress-track">
                    <div
                      class="peach-codex-progress-fill"
                      style={{
                        width: `${Math.round((p().page / p().total) * 100)}%`,
                      }}
                    />
                  </div>
                  <p class="peach-codex-progress-label">
                    page {p().page} of {p().total}
                  </p>
                </>
              )}
            </Show>
          </div>
        </Show>

        <Show
          when={
            phase() === "scanning" ||
            phase() === "ready" ||
            phase() === "restoring"
          }
        >
          <div class="peach-settings-group peach-codex-progress-group">
            <div class="peach-codex-progress-track">
              <div
                class="peach-codex-progress-fill"
                style={{ width: `${progressPercent()}%` }}
              />
            </div>
            <p class="peach-codex-progress-label">
              <Show when={stripeProgressSummary()} fallback={<span>{scanned()} codes scanned</span>}>
                {(summary) => (
                  <span>
                    {summary().ready} / {summary().total} stripes ready
                  </span>
                )}
              </Show>
              <Show when={verifyCode()}>
                <span class="peach-codex-verify-tag">{verifyCode()}</span>
              </Show>
            </p>
            <Show when={stripeProgressSummary()}>
              {(summary) => (
                <p class="peach-codex-hint peach-codex-worst-stripe">
                  least-ready stripe: {summary().worstFound} / {summary().worstRequired} codes
                </p>
              )}
            </Show>
            <p class="peach-codex-hint">{hint()}</p>
            <Show when={scanWarning()}>
              <p class="peach-hint peach-hint--warning peach-codex-warning">
                {scanWarning()}
              </p>
            </Show>
          </div>
        </Show>

        <Show when={phase() === "ready" || phase() === "restoring"}>
          <div class="peach-settings-group peach-codex-passphrase-group">
            <label class="peach-settings-label" for="codex-passphrase">
              master password
            </label>
            <input
              id="codex-passphrase"
              type="password"
              class="peach-underline-input"
              autocomplete="current-password"
              autocorrect="off"
              autocapitalize="none"
              spellcheck={false}
              disabled={phase() === "restoring"}
              value={passphrase()}
              onInput={(e) => {
                setPassphrase((e.target as HTMLInputElement).value);
                if (restoreError()) setRestoreError(null);
              }}
              onKeyDown={(e) => {
                if (e.key === "Enter" && phase() === "ready") {
                  void handleRestore();
                }
              }}
            />
            <Show when={restoreError()}>
              <p class="peach-hint peach-hint-error">{restoreError()}</p>
            </Show>
            <button
              class="peach-btn peach-btn--accent peach-btn--md peach-btn--full"
              disabled={phase() === "restoring" || passphrase().length === 0}
              onClick={() => void handleRestore()}
            >
              {phase() === "restoring" ? "restoring…" : "restore vault"}
            </button>
          </div>
        </Show>

        <Show when={phase() === "success"}>
          <div class="peach-settings-group peach-codex-done">
            <p class="peach-hint peach-hint--success">✓ vault restored</p>
            <p class="peach-codex-meta">
              {restoredCount()}{" "}
              {restoredCount() === 1 ? "entry" : "entries"} recovered.
            </p>
            <p class="peach-codex-footnote">
              your codex has been read and your vault is unlocked.
            </p>
          </div>
        </Show>

        <Show when={phase() !== "success"}>
          <button
            class="peach-btn peach-btn--ghost peach-btn--sm peach-btn--full peach-codex-cancel-btn"
            onClick={props.onBack}
          >
            cancel
          </button>
        </Show>
      </div>
    </div>
  );
}