// Peach Codex — restoration view.
//
// Drives the four steps of restoring a vault from a printed Codex:
//   1. Camera scan — Aztec codes feed parseRawScan → ChunkBuffer.
//   2. Once ChunkBuffer.isReady(), prompt for the master passphrase.
//   3. Reconstruct + integrity-verify locally (popup) via reconstructAndVerify.
//   4. 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,
  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 = "scanning" | "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;

  const [phase, setPhase] = createSignal<Phase>("scanning");
  const [scanned, setScanned] = createSignal(0);
  const [totalShards, setTotalShards] = createSignal<number | null>(null);
  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);
  // 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) {
      setTotalShards(ctx.total);
      setDataShards(ctx.dataShards);
      setVerifyCode(ctx.verifyCode);
    }
    if (buffer.isReady() && phase() === "scanning") {
      setPhase("ready");
      setHint("scan complete. enter your master password to restore.");
    } 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) {
    // Camera permission denied / no camera / hardware failure.
    setCameraError(
      err.name === "NotAllowedError"
        ? "camera access was denied. allow camera permission and reopen this screen."
        : err.message || "camera failed to start.",
    );
  }

  onMount(async () => {
    if (!videoEl) return;
    try {
      scanner = await startScanner({
        videoEl,
        onScan: (text) => void handleScan(text),
        onError: (err) => handleScannerError(err),
      });
    } catch (err) {
      handleScannerError(err instanceof Error ? err : new Error(String(err)));
    }
  });

  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.";
    return error;
  }

  async function handleRestore() {
    if (phase() === "restoring") return;
    const pw = passphrase().trim();
    if (!pw) {
      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" as any,
      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");
      // Tear the camera down ahead of unmount so the green light goes off the
      // instant the success screen appears.
      if (scanner) {
        scanner.stop();
        scanner = null;
      }
      // Give the user a moment to read the success message before the parent
      // routes them onward.
      setTimeout(() => props.onRestoreSuccess(), 1500);
    } else {
      setRestoreError(explainRestoreError(res.error));
      setPhase("ready");
    }
  }

  function progressPercent(): number {
    const ds = dataShards();
    if (!ds || ds <= 0) return 0;
    return Math.min(100, Math.round((scanned() / ds) * 100));
  }

  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() !== "success"}>
          <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() === "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={totalShards() !== null}
                fallback={<span>{scanned()} codes scanned</span>}
              >
                <span>
                  {scanned()} / {dataShards()} codes
                </span>
              </Show>
              <Show when={verifyCode()}>
                <span class="peach-codex-verify-tag">
                  {verifyCode()}
                </span>
              </Show>
            </p>
            <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>
  );
}