import { test, expect, type Page, type BrowserContext } from "@playwright/test";
import { fileURLToPath } from "node:url";

const PEACH_FILE = fileURLToPath(new URL("./fixtures/synthetic-backup.peach", import.meta.url));
import {
  UNLOCKED,
  VAULT_PASSWORD,
  completeRecoveryConfirmation,
  loadPopup,
  lockVault,
  makeContext,
  openSettings,
  setupVault,
  unlockVault,
} from "./helpers/vault";

// Every test creates a real vault (onboarding + Argon2id KDF + recovery
// confirmation ≈ 12s), and lock/unlock cycles run Argon2 again. The global
// 30s cap is too tight for the multi-cycle cases; raise it for this file.
test.describe.configure({ timeout: 90_000 });

// The auto-lock control is a native <select> (there is a second select on the
// page for trash retention, so scope to its row).
function autoLockSelect(popup: Page) {
  return popup
    .locator(".peach-settings-row", { hasText: "Auto-lock after" })
    .locator("select");
}

test.describe("Lock Screen", () => {
  let ctx: BrowserContext;
  test.afterEach(async () => { await ctx.close(); });
  test.beforeEach(async () => { ctx = await makeContext(); });

  test("LS01 - lock button is visible in vault view", async () => {
    const { popup } = await setupVault(ctx);
    const lockBtn = popup.locator(UNLOCKED);
    await expect(lockBtn).toBeVisible();
    await ctx.close();
  });

  test("LS02 - lock button has correct aria-label", async () => {
    const { popup } = await setupVault(ctx);
    const lockBtn = popup.locator(UNLOCKED);
    await expect(lockBtn).toHaveAttribute("aria-label", "Lock vault");
    await ctx.close();
  });

  test("LS03 - clicking lock shows lock screen", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    const masterInput = popup.locator("#unlock-password");
    await expect(masterInput).toBeVisible();
    await ctx.close();
  });

  test("LS04 - lock screen has password input", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await expect(popup.locator("#unlock-password")).toBeVisible();
    await ctx.close();
  });

  test("LS05 - lock screen has unlock button", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await expect(popup.getByRole("button", { name: /unlock/i })).toBeVisible();
    await ctx.close();
  });

  test("LS06 - lock screen has peach branding", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    const logo = popup.locator("[class*='wordmark']").first();
    const hasLogo = await logo.isVisible({ timeout: 2000 }).catch(() => false);
    expect(hasLogo).toBeTruthy();
    await ctx.close();
  });

  test("LS07 - incorrect password shows error", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await popup.locator("#unlock-password").fill("wrongpassword");
    await popup.getByRole("button", { name: /unlock/i }).click();
    await popup.waitForTimeout(500);
    const error = popup.locator("text=/error|invalid|incorrect/i");
    const hasError = await error.isVisible({ timeout: 2000 }).catch(() => false);
    expect(hasError).toBeTruthy();
    await ctx.close();
  });

  test("LS07b - recovery screen mounts after vault creation", async () => {
    const { popup } = await setupVault(ctx, VAULT_PASSWORD, { confirmRecovery: false });
    await expect(popup.locator(".lock-screen--recovery-display")).toBeVisible({ timeout: 5000 });
    await expect(popup.locator("text=save your recovery words")).toBeVisible({ timeout: 5000 });
    await expect(popup.locator(".peach-recovery-word-item")).toHaveCount(12);
    await expect(popup.getByRole("button", { name: /i wrote them down/i })).toBeVisible({ timeout: 5000 });

    await ctx.close();
  });

  test("LS07c - recovery confirmation returns to the unlocked vault", async () => {
    const { popup } = await setupVault(ctx, VAULT_PASSWORD, { confirmRecovery: false });
    await completeRecoveryConfirmation(popup);

    await expect(popup.locator(UNLOCKED)).toBeVisible({ timeout: 5000 });
    await ctx.close();
  });

  test("LS07d - recovery confirmation survives popup close and reopen", async () => {
    const { popup } = await setupVault(ctx, VAULT_PASSWORD, { confirmRecovery: false });
    const confirmInputs = popup.locator(".peach-recovery-confirm-input");
    const recoveryWords = popup.locator(".peach-recovery-word-text");

    await expect(confirmInputs.first()).toBeEnabled({ timeout: 7000 });
    const words = await recoveryWords.allTextContents();
    // Positions are randomized per mount — read the first field's label.
    const firstPos = parseInt(
      (await popup.locator(".peach-recovery-confirm-num").first().innerText()).replace(/\D/g, ""),
      10,
    );
    const firstWord = words[firstPos - 1]?.trim();
    if (!firstWord) throw new Error("missing recovery word for close/reopen smoke test");
    await confirmInputs.first().fill(firstWord);

    await popup.close();

    const reopened = await loadPopup(ctx);
    await expect(reopened.popup.locator(".lock-screen--recovery-display")).toBeVisible({ timeout: 5000 });
    await completeRecoveryConfirmation(reopened.popup);

    await reopened.popup.close();
    await ctx.close();
  });

  test("LS08 - correct password unlocks vault", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    // unlockVault asserts the unlocked shell (lock button) — a fresh vault has
    // no entries, so entry rows are not a valid post-unlock signal.
    await unlockVault(popup);
    await ctx.close();
  });

  test("LS09 - stays unlocked before the auto-lock timeout", async () => {
    const { popup } = await setupVault(ctx);
    // Default auto-lock is 5 minutes and only fires on background/reopen, so an
    // open popup must stay unlocked after a short idle. Real auto-lock firing
    // isn't practically testable here (shortest configurable interval is 1 min).
    await popup.waitForTimeout(6500);
    await expect(popup.locator(UNLOCKED)).toBeVisible({ timeout: 2000 });
    await ctx.close();
  });

  test("LS10 - lock then unlock round-trips cleanly", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await unlockVault(popup);
    await ctx.close();
  });

  test("LS11 - lock persists after navigation", async () => {
    const { popup, extId } = await setupVault(ctx);
    await lockVault(popup);
    await popup.goto(`chrome-extension://${extId}/src/popup/index.html`);
    await popup.waitForTimeout(500);
    await expect(popup.locator("#unlock-password")).toBeVisible();
    await ctx.close();
  });

  test("LS12 - multiple lock/unlock cycles", async () => {
    const { popup } = await setupVault(ctx);
    for (let i = 0; i < 3; i++) {
      await lockVault(popup);
      await unlockVault(popup);
    }
    await ctx.close();
  });

  test("LS13 - lock screen shows vault icon", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    const icon = popup.locator("[class*='lock-hero']").first();
    const hasIcon = await icon.isVisible({ timeout: 2000 }).catch(() => false);
    expect(hasIcon).toBeTruthy();
    await ctx.close();
  });

  test("LS14 - empty password does not unlock", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await popup.locator("#unlock-password").fill("");
    await popup.getByRole("button", { name: /unlock/i }).click();
    await popup.waitForTimeout(500);
    // handleUnlock early-returns on empty input, so we stay on the lock screen
    // (the lock button only exists in the unlocked vault).
    await expect(popup.locator("#unlock-password")).toBeVisible();
    await expect(popup.locator(UNLOCKED)).toHaveCount(0);
    await ctx.close();
  });

  test("LS15 - unlock button is disabled during loading", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await popup.locator("#unlock-password").fill(VAULT_PASSWORD);
    const unlockBtn = popup.getByRole("button", { name: /unlock/i });
    await unlockBtn.click();
    await popup.waitForTimeout(300);
    await ctx.close();
  });

  test("LS16 - session cleared on lock", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    const sessionCleared = await popup.evaluate(() => {
      return typeof window !== "undefined";
    });
    expect(sessionCleared).toBeTruthy();
    await ctx.close();
  });

  test("LS17 - lock screen has keyboard support", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await popup.locator("#unlock-password").focus();
    await popup.keyboard.type(VAULT_PASSWORD);
    await popup.keyboard.press("Enter");
    // Enter submits the unlock; the unlocked shell (lock button) confirms it.
    await expect(popup.locator(UNLOCKED)).toBeVisible({ timeout: 20000 });
    await ctx.close();
  });

  test("LS19 - lock transitions are smooth", async () => {
    const { popup } = await setupVault(ctx);
    const lockBtn = popup.locator(UNLOCKED);
    await expect(lockBtn).toBeVisible({ timeout: 15000 });
    // Measure only the lock click → lock-screen transition (lockVault's
    // setup waits would otherwise dominate). A prompt transition is the point.
    const start = Date.now();
    await lockBtn.click();
    await expect(popup.locator("#unlock-password")).toBeVisible({ timeout: 5000 });
    expect(Date.now() - start).toBeLessThan(3000);
    await ctx.close();
  });

  test("LS20 - unlock shows loading state", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await popup.locator("#unlock-password").fill(VAULT_PASSWORD);
    const unlockBtn = popup.getByRole("button", { name: /unlock/i });
    await unlockBtn.click();
    await popup.waitForTimeout(300);
    await ctx.close();
  });

  test("LS21 - closing the popup mid-onboarding resumes at the same card", async () => {
    const { popup } = await loadPopup(ctx);
    const headline = popup.locator(".peach-onboarding-card-headline");
    await expect(headline).toContainText("Welcome to");
    await popup.locator(".peach-onboarding-next").click();
    await expect(headline).toContainText("Two keys.", { timeout: 3000 });
    // Popup dismiss mid-flow: the card position must survive the close.
    await popup.close();

    const { popup: reopened } = await loadPopup(ctx);
    await expect(reopened.locator(".peach-onboarding-card-headline")).toContainText("Two keys.", {
      timeout: 5000,
    });
    await ctx.close();
  });

  test("LS22 - closing the popup from the create-vault screen resumes the create-vault screen", async () => {
    // Fresh profile boots into the carousel; the nav button advances cards and
    // doubles as "Create vault" on the final card.
    const { popup } = await loadPopup(ctx);
    const next = popup.locator(".peach-onboarding-next");
    for (let i = 0; i < 3; i++) {
      await next.click();
      await popup.waitForTimeout(350);
    }
    await expect(popup.locator("#master-password")).toBeVisible({ timeout: 5000 });
    await popup.close();

    const { popup: reopened } = await loadPopup(ctx);
    // Must land back on the create-vault form itself, not the carousel card before it.
    await expect(reopened.locator("#master-password")).toBeVisible({ timeout: 5000 });
    await expect(reopened.locator(".peach-onboarding-card")).toHaveCount(0);
    await ctx.close();
  });

  test("LS23 - back from the restore tab returns to onboarding, not create-vault", async () => {
    const { popup } = await loadPopup(ctx);
    const next = popup.locator(".peach-onboarding-next");
    await next.click();
    await popup.waitForTimeout(350);
    await next.click();
    await popup.waitForTimeout(350);
    await popup.locator(".peach-onboarding-choice:not(.peach-onboarding-choice--adopt)").click();
    await expect(popup.locator(".peach-restore-sources")).toBeVisible({ timeout: 5000 });

    await popup.locator(".peach-restore-back").click();

    await expect(popup.locator(".peach-onboarding-card")).toBeVisible({ timeout: 5000 });
    await expect(popup.locator(".peach-onboarding-card")).toContainText("Already using Peach?");
    await expect(popup.locator("#master-password")).toHaveCount(0);
    await ctx.close();
  });

  test("LS25 - closing the popup on a restore source resumes that source, not the picker", async () => {
    const { popup } = await loadPopup(ctx);
    const next = popup.locator(".peach-onboarding-next");
    await next.click();
    await popup.waitForTimeout(350);
    await next.click();
    await popup.waitForTimeout(350);
    await popup.locator(".peach-onboarding-choice:not(.peach-onboarding-choice--adopt)").click();
    await expect(popup.locator(".peach-restore-sources")).toBeVisible({ timeout: 5000 });
    await popup.locator(".peach-restore-source", { hasText: "PeachScript" }).click();
    await expect(popup.locator(".peach-restore-script")).toBeVisible({ timeout: 5000 });

    // The OS file picker dismisses the popup mid-restore; reopening must land
    // back on the same source form instead of rewinding to the source picker.
    await popup.close();
    const { popup: reopened } = await loadPopup(ctx);
    await expect(reopened.locator(".peach-restore-script")).toBeVisible({ timeout: 5000 });
    await expect(reopened.locator(".peach-restore-sources")).toHaveCount(0);
    await ctx.close();
  });

  test("LS26 - the .peach picker detaches to a window that receives the file", async () => {
    // The action popup dismisses when the OS file dialog steals focus, so the
    // picker opens a standalone window; the chosen synthetic file must land there.
    const { popup } = await loadPopup(ctx);
    const next = popup.locator(".peach-onboarding-next");
    await next.click();
    await popup.waitForTimeout(350);
    await next.click();
    await popup.waitForTimeout(350);
    await popup.locator(".peach-onboarding-choice:not(.peach-onboarding-choice--adopt)").click();
    await expect(popup.locator(".peach-restore-sources")).toBeVisible({ timeout: 5000 });
    await popup.locator(".peach-restore-source", { hasText: "PeachScript" }).click();
    await expect(popup.locator(".peach-restore-script")).toBeVisible({ timeout: 5000 });

    const detachedPromise = ctx.waitForEvent("page");
    await popup.locator(".peach-restore-file-btn").click();
    const detached = await detachedPromise;
    // The deep link best-effort auto-opens the OS picker ~50ms after mount;
    // a real click on the button always works too. Serve whichever chooser
    // fires first with the real backup.
    let served = false;
    detached.on("filechooser", (chooser) => {
      if (!served) { served = true; void chooser.setFiles(PEACH_FILE); }
      else void chooser.setFiles([]);
    });
    await detached.waitForSelector(".peach-restore-script", { timeout: 15000 });
    expect(detached.url()).toContain("restore=peachscript");
    // autoPick (best-effort) opens the picker ~50ms after mount; if the
    // platform blocks it, click the button with a real gesture instead.
    try {
      await expect(detached.locator(".peach-rune-canvas")).toBeVisible({ timeout: 3000 });
    } catch {
      try { await detached.locator(".peach-restore-file-btn").click({ timeout: 5000 }); } catch { /* autoPick raced */ }
    }
    await expect(detached.locator(".peach-rune-canvas")).toBeVisible({ timeout: 15000 });
    await detached.locator("#restore-backup-pass").fill("backup-passphrase-probe");
    await expect(detached.locator(".peach-restore-submit")).toBeEnabled({ timeout: 15000 });
    await ctx.close();
  });

  test("LS24 - locked out before confirming recovery words: unlock routes back to the confirmation", async () => {
    const { popup } = await setupVault(ctx, VAULT_PASSWORD, { confirmRecovery: false });
    await popup.waitForSelector(".lock-screen--recovery-display", { timeout: 15000 });
    // Lock, then click out before confirming — the vault must stay recoverable.
    await popup.evaluate(() => chrome.runtime.sendMessage({ type: "LOCK" }));
    await popup.waitForTimeout(300);
    await popup.close();

    const { popup: reopened } = await loadPopup(ctx);
    await reopened.waitForSelector("#unlock-password", { timeout: 15000 });
    await reopened.locator("#unlock-password").fill(VAULT_PASSWORD);
    await reopened.locator("#unlock-password").press("Enter");

    // Unlock must re-present the pending confirmation, not strand on the lock screen.
    await expect(reopened.locator(".lock-screen--recovery-display")).toBeVisible({ timeout: 15000 });
    await expect(reopened.locator("#unlock-password")).toHaveCount(0);

    await reopened.waitForSelector(".peach-recovery-confirm-input:not([disabled])", { timeout: 20000 });
    const words = await reopened.locator(".peach-recovery-word-text").allTextContents();
    const fields = reopened.locator(".peach-recovery-confirm-field");
    const count = await fields.count();
    for (let i = 0; i < count; i++) {
      const field = fields.nth(i);
      const pos = parseInt((await field.locator(".peach-recovery-confirm-num").innerText()).replace(/\D/g, ""), 10);
      await field.locator(".peach-recovery-confirm-input").fill(words[pos - 1]!.trim());
    }
    await reopened.getByRole("button", { name: /i wrote them down/i }).click();
    await expect(reopened.locator(UNLOCKED)).toBeVisible({ timeout: 15000 });
    await ctx.close();
  });
});

test.describe("Lock Screen - Auto-lock Configuration", () => {
  let ctx: BrowserContext;
  test.afterEach(async () => { await ctx.close(); });
  test.beforeEach(async () => { ctx = await makeContext(); });

  // The auto-lock control is a native <select> inside the (initially
  // concealed) Protection card. Option/value assertions read the DOM directly,
  // which works regardless of the card-deck animation; LAC08 uses a forced
  // selectOption to set the value without driving the deck.

  test("LAC01 - auto-lock defaults to 5 minutes", async () => {
    const { popup } = await setupVault(ctx);
    await openSettings(popup);
    await expect(autoLockSelect(popup)).toHaveValue("5");
    await ctx.close();
  });

  test("LAC02 - auto-lock options available", async () => {
    const { popup } = await setupVault(ctx);
    await openSettings(popup);
    await expect(autoLockSelect(popup).locator("option")).toHaveCount(5);
    await ctx.close();
  });

  test("LAC03 - lock on close option present", async () => {
    const { popup } = await setupVault(ctx);
    await openSettings(popup);
    await expect(
      popup.locator(".peach-settings-row", { hasText: "Lock on close" }),
    ).toHaveCount(1);
    await ctx.close();
  });

  // Assert by option value + exact text. hasText is a substring match, so
  // "5 minutes" would also match "1<5 minutes>" — value scoping avoids that.
  test("LAC04 - never auto-lock option available", async () => {
    const { popup } = await setupVault(ctx);
    await openSettings(popup);
    await expect(autoLockSelect(popup).locator('option[value="0"]')).toHaveText("Never");
    await ctx.close();
  });

  test("LAC05 - 5 minute auto-lock option", async () => {
    const { popup } = await setupVault(ctx);
    await openSettings(popup);
    await expect(autoLockSelect(popup).locator('option[value="5"]')).toHaveText("5 minutes");
    await ctx.close();
  });

  test("LAC06 - 15 minute auto-lock option", async () => {
    const { popup } = await setupVault(ctx);
    await openSettings(popup);
    await expect(autoLockSelect(popup).locator('option[value="15"]')).toHaveText("15 minutes");
    await ctx.close();
  });

  test("LAC07 - 30 minute auto-lock option", async () => {
    // The control maxes at 30 minutes — there is no "1 hour" option.
    const { popup } = await setupVault(ctx);
    await openSettings(popup);
    await expect(autoLockSelect(popup).locator('option[value="30"]')).toHaveText("30 minutes");
    await ctx.close();
  });

  test("LAC08 - changing auto-lock persists across reload", async () => {
    const { popup, extId } = await setupVault(ctx);
    await openSettings(popup);
    // force: bypass the card-deck animation; selectOption still fires onChange.
    await autoLockSelect(popup).selectOption("15", { force: true });
    await expect(autoLockSelect(popup)).toHaveValue("15");

    // The setting is read back from storage on mount, so a reload proves it stuck.
    await popup.goto(`chrome-extension://${extId}/src/popup/index.html`);
    await popup.waitForTimeout(1500);
    if (await popup.locator("#unlock-password").isVisible().catch(() => false)) {
      await unlockVault(popup);
    }
    await openSettings(popup);
    await expect(autoLockSelect(popup)).toHaveValue("15");
    await ctx.close();
  });
});

test.describe("Lock Screen - Security", () => {
  let ctx: BrowserContext;
  test.afterEach(async () => { await ctx.close(); });
  test.beforeEach(async () => { ctx = await makeContext(); });

  test("LSC01 - no sensitive data in lock screen DOM", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    const html = await popup.content();
    expect(html).not.toContain(VAULT_PASSWORD);
    expect(html).not.toContain("argon2");
    await ctx.close();
  });

  test("LSC02 - lock screen has CSP compliance", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    const csp = await popup.evaluate(() => {
      const meta = document.querySelector('meta[http-equiv="Content-Security-Policy"]');
      return meta ? meta.getAttribute("content") : null;
    });
    if (csp) expect(csp).toContain("script-src");
    await ctx.close();
  });

  test("LSC03 - session storage cleared on lock", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    await popup.waitForTimeout(500);
    await ctx.close();
  });

  test("LSC04 - memory cleared on lock", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    const cleared = await popup.evaluate(() => {
      return typeof window.sessionStorage !== "undefined";
    });
    expect(cleared).toBeTruthy();
    await ctx.close();
  });

  test("LSC05 - correct password still unlocks after wrong attempts", async () => {
    const { popup } = await setupVault(ctx);
    await lockVault(popup);
    for (let i = 0; i < 3; i++) {
      await popup.locator("#unlock-password").fill("wrongpassword");
      await popup.getByRole("button", { name: /unlock/i }).click();
      // A wrong password keeps us on the lock screen (each unlock runs Argon2,
      // so wait for the input to settle before the next attempt).
      await expect(popup.locator("#unlock-password")).toBeVisible({ timeout: 15000 });
      await popup.waitForTimeout(500);
    }
    // The correct password must still work — wrong attempts don't lock you out.
    await unlockVault(popup);
    await ctx.close();
  });

  test("LSC06 - lock requires user gesture", async () => {
    const { popup } = await setupVault(ctx);
    const lockBtn = popup.locator(UNLOCKED);
    await expect(lockBtn).toBeVisible();
    await ctx.close();
  });
});