import { expect, test as base, type APIRequestContext, type APIResponse, type Page, type Response, type TestInfo } from '@playwright/test';
import AxeBuilder from '@axe-core/playwright';
import { translations } from '../src/i18n/translations';
import type { CvTheme, CvVariant, CvVariantSummary } from '../src/cvBuilder';
import { emptyStructuredCv } from '../src/profileCv';

const apiUrl = 'http://localhost:5302/api';
const password = 'E2ePassword123!';
type Owner = { id: string; headers: Record<string, string> };
type Sample = { language: 'en' | 'nb'; theme: 'light' | 'dark'; width: number; height: number };
const desktop: Sample = { language: 'en', theme: 'light', width: 1440, height: 900 };

function settings(themeId: string) {
  return { themeId, showPhoto: false, showPageNumbers: false, showIcons: true, sections: [], overrides: {}, customSections: [] };
}

async function json<T>(response: APIResponse | Response, status = 200): Promise<T> {
  expect(response.status(), `${response.url()} must return ${status}`).toBe(status);
  return response.json();
}

async function login(api: APIRequestContext, email: string): Promise<Owner> {
  expect((await api.post(`${apiUrl}/auth/login`, { data: { email, password } })).status()).toBe(200);
  const me = await json<{ id: string; sessionContext: string }>(await api.get(`${apiUrl}/auth/me`));
  const csrf = (await api.storageState()).cookies.find(cookie => cookie.name === 'XSRF-TOKEN');
  expect(csrf).toBeDefined();
  return { id: me.id, headers: { 'X-CSRF-TOKEN': csrf!.value, 'X-Session-Context': me.sessionContext } };
}

async function createOwner(admin: APIRequestContext, owner: Owner) {
  const email = `p7-cv-library-${Date.now()}-${Math.random().toString(36).slice(2)}@example.test`;
  expect((await admin.post(`${apiUrl}/users`, { headers: owner.headers, data: { email, password, roles: [] } })).status()).toBe(200);
  return email;
}

const test = base.extend<{ owner: Owner }>({
  owner: async ({ page, context, playwright }, provide, info) => {
    expect(process.env.PLAYWRIGHT_REUSE_SERVERS).not.toBe('true');
    expect(info.config.metadata.isolatedDataRoot).toEqual(expect.any(String));
    const admin = await playwright.request.newContext();
    try {
      const administrator = await login(admin, 'e2e@example.test');
      const owner = await login(page.request, await createOwner(admin, administrator));
      await context.route('**/*', route => {
        const url = new URL(route.request().url());
        return ['localhost', '127.0.0.1'].includes(url.hostname) || ['data:', 'blob:', 'about:'].includes(url.protocol)
          ? route.continue() : route.abort();
      });
      await provide(owner);
    } finally { await admin.dispose(); }
  },
});

async function seedSource(page: Page, owner: Owner) {
  const profile = { ...emptyStructuredCv(), contact: { ...emptyStructuredCv().contact,
    fullName: 'Åse Nordlys — recorded owner-reviewed professional identity', headline: 'Recorded professional context', email: 'recorded-contact@example.test' },
    jobs: [{ id: 'library-source-job', title: 'Recorded engineer', company: 'Nordlys AS', bullets: ['Recorded source evidence.'], skills: ['C#'] }],
    summary: ['Reviewed canonical summary, kept separate from CV-specific presentation.'] };
  await json(await page.request.put(`${apiUrl}/career/profile`, { headers: owner.headers,
    data: { profile, cvText: 'Exact owner-reviewed source — æøå\nRecorded work.\n' } }));
  return readSource(page.request);
}

async function readSource(api: APIRequestContext) {
  return { canonical: await json<unknown>(await api.get(`${apiUrl}/career/profile`)),
    history: await json<unknown[]>(await api.get(`${apiUrl}/career/profile/versions`)) };
}

async function createVariant(api: APIRequestContext, owner: Owner, name: string, jobApplicationId?: number) {
  return json<CvVariant>(await api.post(`${apiUrl}/cv/variants`, { headers: owner.headers,
    data: { name, jobApplicationId, settings: { ...settings('minimal'), language: 'nb-NO',
      overrides: { 'library-source-job': { title: 'CV-specific reviewed title', bullets: ['CV-specific reviewed evidence.'] } } } } }));
}

async function enter(page: Page, owner: Owner, sample: Sample = desktop) {
  expect((await page.request.put(`${apiUrl}/auth/preferences/language`, { headers: owner.headers,
    data: { language: sample.language === 'nb' ? 'nb-NO' : 'en' } })).status()).toBe(204);
  await page.addInitScript(({ language, theme }) => {
    if (localStorage.getItem('uiLanguage') === null) localStorage.setItem('uiLanguage', language);
    if (localStorage.getItem('jobtracker.themeMode') === null) localStorage.setItem('jobtracker.themeMode', theme);
  }, sample);
  await page.setViewportSize({ width: sample.width, height: sample.height });
  await page.emulateMedia({ reducedMotion: 'reduce' });
  await page.goto('/career/builder?source=phase7-library#preserved');
  const stored = await page.evaluate(() => ({ language: localStorage.getItem('uiLanguage'), theme: localStorage.getItem('jobtracker.themeMode') }));
  if (stored.language !== sample.language || stored.theme !== sample.theme) {
    await page.evaluate(({ language, theme }) => {
      localStorage.setItem('uiLanguage', language); localStorage.setItem('jobtracker.themeMode', theme);
    }, sample);
    await page.reload();
  }
  await expect(page.locator('html')).toHaveAttribute('lang', sample.language === 'nb' ? 'nb-NO' : 'en');
  await expect(page.locator('html')).toHaveAttribute('data-color-scheme', sample.theme);
  await expect(page.getByRole('heading', { level: 1 })).toHaveCount(1);
  await expect(page.getByRole('heading', { level: 1 })).toBeVisible();
  await expect(page.getByRole('heading', { level: 2, name: translations[sample.language].cvDashboardLibraryTitle, exact: true })).toBeVisible();
}

function card(page: Page, name: string, language: Sample['language'] = 'en') {
  return page.getByRole('link', { name: translations[language].cvDashboardOpenNamed.replace('{name}', name), exact: true });
}

function actionButton(page: Page, name: string, language: Sample['language'] = 'en') {
  return page.getByRole('button', { name: translations[language].cvDashboardActionsFor.replace('{name}', name), exact: true });
}

async function openAction(page: Page, name: string, action: string, language: Sample['language'] = 'en') {
  await actionButton(page, name, language).focus();
  await page.keyboard.press('Enter');
  const menu = page.getByRole('menu');
  await expect(menu).toBeVisible();
  await menu.getByRole('menuitem', { name: action, exact: true }).focus();
  await page.keyboard.press('Enter');
}

async function openCreate(page: Page, language: Sample['language'] = 'en') {
  const t = translations[language];
  await page.getByRole('button', { name: t.cvDashboardNewCv, exact: true }).click();
  const dialog = page.getByRole('dialog', { name: t.cvDashboardCreateTitle, exact: true });
  await expect(dialog).toBeVisible();
  return dialog;
}

async function capture(page: Page, info: TestInfo, sample: Sample, state: string) {
  await page.evaluate(async () => { await document.fonts.ready; await new Promise<void>(resolve => requestAnimationFrame(() => requestAnimationFrame(() => resolve()))); });
  const geometry = await page.evaluate(() => ({ width: innerWidth, height: innerHeight,
    rootOverflow: Math.max(0, document.documentElement.scrollWidth - document.documentElement.clientWidth),
    overflowElements: [...document.querySelectorAll('body *')]
      .filter(element => element.getClientRects().length > 0 && getComputedStyle(element).visibility !== 'hidden' && !element.closest('[hidden],[aria-hidden="true"]'))
      .map(element => { const rect = element.getBoundingClientRect(); return { tag: element.tagName, text: (element.textContent ?? '').slice(0, 100), left: rect.left, right: rect.right, width: rect.width }; })
      .filter(element => element.width > 0 && (element.left < -1 || element.right > innerWidth + 1)).slice(0, 20),
  }));
  const axe = await new AxeBuilder({ page }).options({ rules: { 'target-size': { enabled: true } } }).analyze();
  const name = `p7-cv-library-${sample.language}-${sample.theme}-${sample.width}-${state}`;
  await info.attach(`${name}-audit`, { body: JSON.stringify({ sample, state, geometry, ariaSnapshot: await page.locator('body').ariaSnapshot(),
    axe: { scope: 'All enabled rules plus target-size; complete findings retained', violations: axe.violations, incomplete: axe.incomplete,
      passes: axe.passes.map(rule => ({ id: rule.id, nodes: rule.nodes.length })) },
    qualifications: ['Automated Chromium only; incomplete axe findings require triage and do not establish human screen-reader acceptance.',
      'No physical touch/software keyboard, actual browser zoom, production font/photo, print/PDF fidelity, model/provider or production acceptance.'],
  }), contentType: 'application/json' });
  await info.attach(name, { body: await page.screenshot({ fullPage: true, animations: 'disabled' }), contentType: 'image/png' });
  expect(geometry.rootOverflow).toBe(0);
  expect(axe.violations).toEqual([]);
}

test('[P7-04 PRES-C05 E08] failed list has an explicit keyboard retry with held progress, stable focus and actual recovery', async ({ page, owner }, info) => {
  const sourceBefore = await seedSource(page, owner);
  const existing = await createVariant(page.request, owner, 'Recorded recovery CV');
  let reads = 0;
  let release!: () => void;
  const held = new Promise<void>(resolve => { release = resolve; });
  await page.route('**/api/cv/variants', async route => {
    if (route.request().method() !== 'GET') return route.continue();
    reads++;
    if (reads === 1) return route.fulfill({ status: 500, contentType: 'application/json', body: JSON.stringify({ message: 'Controlled library read unavailable' }) });
    if (reads === 2) await held;
    return route.continue();
  });
  await enter(page, owner);
  await expect(page.getByText('Controlled library read unavailable', { exact: true })).toBeVisible();
  const retry = page.getByRole('button', { name: translations.en.retry, exact: true });
  const content = page.getByRole('region', { name: translations.en.cvDashboardTitle, exact: true });
  try {
    await retry.focus(); await page.keyboard.press('Enter');
    await expect.poll(() => reads).toBe(2);
    await expect(content).toBeFocused();
    await expect(page.getByRole('progressbar', { name: translations.en.loading, exact: true })).toBeVisible();
    await expect(content.getByRole('status')).toHaveText(translations.en.loading);
    await expect(content.getByRole('status')).toHaveAttribute('aria-live', 'polite');
    await page.keyboard.press('Enter');
    expect(reads).toBe(2);
  } finally { release(); }
  await expect(card(page, existing.name)).toBeVisible();
  await expect(page.getByText('Controlled library read unavailable', { exact: true })).toHaveCount(0);
  await expect(content).toBeFocused();
  expect(reads).toBe(2);
  expect(await readSource(page.request)).toEqual(sourceBefore);
  await capture(page, info, desktop, 'list-recovered');
  await info.attach('library-list-recovery', { body: JSON.stringify({ reads, qualification: 'First read is a controlled500; explicit retry is held before continuing the actual HTTP GET. No successful CV response is fabricated.' }), contentType: 'application/json' });
});

test('[P7-04 PRES-C05 C08 E08] locale-retained create draft locks during held failure and retries one identical snapshot', async ({ page, owner }, info) => {
  test.setTimeout(90_000);
  const sourceBefore = await seedSource(page, owner);
  const themes = await json<CvTheme[]>(await page.request.get(`${apiUrl}/cv/themes`));
  const selected = themes.find(theme => theme.id === 'minimal' && theme.available)!;
  expect(selected).toBeDefined();
  let listReads = 0;
  let themeReads = 0;
  const payloads: unknown[] = [];
  let release!: () => void;
  const held = new Promise<void>(resolve => { release = resolve; });
  await page.route('**/api/cv/variants', async route => {
    if (route.request().method() === 'GET') { listReads++; return route.continue(); }
    if (route.request().method() !== 'POST') return route.continue();
    payloads.push(route.request().postDataJSON());
    if (payloads.length === 1) {
      await held;
      return route.fulfill({ status: 500, contentType: 'application/json', body: JSON.stringify({ message: 'Controlled create unavailable' }) });
    }
    return route.continue();
  });
  await page.route('**/api/cv/themes', route => { themeReads++; return route.continue(); });
  await enter(page, owner, { ...desktop, width: 360, height: 844 });
  await expect(page.getByText(translations.en.cvDashboardEmptyTitle, { exact: true })).toBeVisible();
  const name = 'Backendutvikler — Åse sin gjennomgåtte CV med en lang, beskrivende tittel';
  let dialog = await openCreate(page);
  await dialog.getByLabel(translations.en.cvEditorName, { exact: false }).fill(name);
  await dialog.getByRole('button', { name: selected.name, exact: true }).focus(); await page.keyboard.press('Enter');
  await expect(dialog.getByRole('button', { name: selected.name, exact: true })).toHaveAttribute('aria-pressed', 'true');
  await dialog.getByRole('button', { name: translations.en.cancel, exact: true }).click();
  const readsBeforeLocale = { listReads, themeReads };
  const saved = page.waitForResponse(response => response.url() === `${apiUrl}/auth/preferences/language` && response.request().method() === 'PUT');
  await page.locator('header').getByRole('button', { name: 'Norsk', exact: true }).click();
  expect((await saved).status()).toBe(204);
  await expect(page.locator('html')).toHaveAttribute('lang', 'nb-NO');
  dialog = await openCreate(page, 'nb');
  await expect(dialog.getByLabel(translations.nb.cvEditorName, { exact: false })).toHaveValue(name);
  await expect(dialog.getByRole('button', { name: selected.name, exact: true })).toHaveAttribute('aria-pressed', 'true');
  expect({ listReads, themeReads }).toEqual(readsBeforeLocale);
  try {
    await dialog.getByRole('button', { name: translations.nb.cvDashboardCreateCv, exact: true }).focus(); await page.keyboard.press('Enter');
    await expect.poll(() => payloads.length).toBe(1);
    await expect(dialog.getByLabel(translations.nb.cvEditorName, { exact: false })).toHaveAttribute('required', '');
    await expect(dialog.getByLabel(translations.nb.cvEditorName, { exact: false })).toBeDisabled();
    await expect(dialog.getByRole('button', { name: translations.nb.cancel, exact: true })).toBeDisabled();
    await expect(dialog.getByRole('button', { name: translations.nb.cvEditorAtsTemplates, exact: true })).toBeDisabled();
    await expect(dialog.getByRole('button', { name: selected.name, exact: true })).toHaveAttribute('aria-disabled', 'true');
    await page.keyboard.press('Enter'); await page.keyboard.press('Escape');
    await expect(dialog).toBeVisible(); expect(payloads).toHaveLength(1);
    const content = dialog.getByRole('region', { name: translations.nb.cvDashboardCreateTitle, exact: true });
    await page.keyboard.press('Tab');
    await expect(content).toBeFocused();
    const scrollBefore = await content.evaluate(element => ({ top: element.scrollTop, height: element.clientHeight, scrollHeight: element.scrollHeight }));
    if (scrollBefore.scrollHeight > scrollBefore.height + 1) {
      await page.keyboard.press(scrollBefore.top > 0 ? 'PageUp' : 'PageDown');
      if (scrollBefore.top > 0) await expect.poll(() => content.evaluate(element => element.scrollTop)).toBeLessThan(scrollBefore.top);
      else await expect.poll(() => content.evaluate(element => element.scrollTop)).toBeGreaterThan(scrollBefore.top);
    }
    await info.attach('library-held-create-keyboard-scroll', { body: JSON.stringify({ scrollBefore,
      scrollAfter: await content.evaluate(element => element.scrollTop),
      qualification: 'Actual Tab reaches the named pending-dialog content; PageUp/PageDown is exercised when this viewport has vertical content overflow. Browser keyboard evidence does not establish physical touch/software-keyboard or human screen-reader acceptance.' }), contentType: 'application/json' });
    await capture(page, info, { language: 'nb', theme: 'light', width: 360, height: 844 }, 'held-create');
  } finally { release(); }
  await expect(dialog.getByText('Controlled create unavailable', { exact: true })).toBeVisible();
  await expect(dialog.getByLabel(translations.nb.cvEditorName, { exact: false })).toHaveValue(name);
  await expect(dialog.getByRole('button', { name: selected.name, exact: true })).toHaveAttribute('aria-pressed', 'true');
  const createdResponse = page.waitForResponse(response => response.url() === `${apiUrl}/cv/variants` && response.request().method() === 'POST');
  await dialog.getByRole('button', { name: translations.nb.cvDashboardCreateCv, exact: true }).click();
  const created = await json<CvVariant>(await createdResponse);
  await expect(page).toHaveURL(new RegExp(`/career/builder/${created.id}(?:[?#]|$)`));
  expect(payloads).toHaveLength(2); expect(payloads[1]).toEqual(payloads[0]);
  expect(created).toMatchObject({ name, isPublic: false, version: 1, settings: { themeId: 'minimal' } });
  expect(await json<CvVariant>(await page.request.get(`${apiUrl}/cv/variants/${created.id}`))).toEqual(created);
  expect(await readSource(page.request)).toEqual(sourceBefore);
  await info.attach('library-create-recovery', { body: JSON.stringify({ readsBeforeLocale, listReads, themeReads, payloads, created,
    qualification: 'Locale is changed through the real header after cancelling the draft dialog. First create is a controlled500; only explicit retry reaches actual HTTP creation. No model/provider or source write.' }), contentType: 'application/json' });
});

test('[P7-04 PRES-C05 C07 C10 W07] keyboard rename duplicate and delete persist without changing source, settings or frozen packages', async ({ page, owner }, info) => {
  test.setTimeout(90_000);
  const sourceBefore = await seedSource(page, owner);
  const company = await json<{ id: number }>(await page.request.post(`${apiUrl}/companies`, { headers: owner.headers, data: { name: 'Recorded library fixture AS' } }), 201);
  const job = await json<{ id: number }>(await page.request.post(`${apiUrl}/jobapplications`, { headers: owner.headers,
    data: { companyId: company.id, jobTitle: 'Recorded library association', status: 'Saved' } }), 201);
  const original = await createVariant(page.request, owner, 'Recorded original CV', job.id);
  expect((await page.request.put(`${apiUrl}/jobapplications/${job.id}/cv`, { headers: owner.headers, data: { variantId: original.id } })).status()).toBe(200);
  const frozen = await json<{ id: number }>(await page.request.post(`${apiUrl}/jobapplications/${job.id}/submitted-packages`, { headers: owner.headers }));
  const frozenUrl = `${apiUrl}/jobapplications/${job.id}/submitted-packages/${frozen.id}`;
  const frozenBefore = await json<unknown>(await page.request.get(frozenUrl));
  await enter(page, owner);
  const renamedName = 'Recorded renamed CV — explicit owner review';
  await openAction(page, original.name, translations.en.cvDashboardRename);
  const prompt = page.getByRole('dialog');
  await expect(prompt.getByRole('textbox')).toBeFocused();
  await prompt.getByRole('textbox').fill(renamedName);
  const renamedResponse = page.waitForResponse(response => response.url() === `${apiUrl}/cv/variants/${original.id}` && response.request().method() === 'PUT');
  await prompt.getByRole('button', { name: translations.en.cvDashboardRename, exact: true }).click();
  const renameResponse = await renamedResponse;
  const renamed = await json<CvVariant>(renameResponse);
  expect(renameResponse.request().postDataJSON()).toMatchObject({ name: renamedName, source: 'manual', expectedVersion: original.version, settings: original.settings });
  expect(renamed.settings).toEqual(original.settings); expect(renamed.version).toBe(original.version + 1);
  await expect(card(page, renamedName)).toBeVisible();
  await expect(actionButton(page, renamedName)).toBeFocused();
  let duplicateWrites = 0;
  let release!: () => void;
  const held = new Promise<void>(resolve => { release = resolve; });
  await page.route(`**/api/cv/variants/${original.id}/duplicate`, async route => { duplicateWrites++; await held; return route.continue(); });
  const duplicatedResponse = page.waitForResponse(response => response.url() === `${apiUrl}/cv/variants/${original.id}/duplicate` && response.request().method() === 'POST');
  try {
    await openAction(page, renamedName, translations.en.cvEditorDuplicate);
    await expect.poll(() => duplicateWrites).toBe(1);
    await expect(actionButton(page, renamedName)).toBeDisabled();
    await page.keyboard.press('Enter');
    expect(duplicateWrites).toBe(1);
  } finally { release(); }
  const copy = await json<CvVariant>(await duplicatedResponse);
  expect(copy).toMatchObject({ name: `${renamedName} (copy)`, version: 1, isPublic: false, jobApplicationId: job.id });
  expect(copy.id).not.toBe(original.id); expect(copy.publicSlug).not.toBe(original.publicSlug); expect(copy.settings).toEqual(renamed.settings);
  await expect(card(page, copy.name)).toBeVisible();
  await openAction(page, copy.name, translations.en.cvDashboardDelete);
  const confirmation = page.getByRole('dialog');
  await expect(confirmation.getByRole('button', { name: translations.en.cancel, exact: true })).toBeFocused();
  await page.keyboard.press('Enter');
  await expect(confirmation).toHaveCount(0);
  await expect(actionButton(page, copy.name)).toBeFocused();
  expect((await page.request.get(`${apiUrl}/cv/variants/${copy.id}`)).status()).toBe(200);
  await openAction(page, copy.name, translations.en.cvDashboardDelete);
  const deletedResponse = page.waitForResponse(response => response.url() === `${apiUrl}/cv/variants/${copy.id}` && response.request().method() === 'DELETE');
  await page.getByRole('dialog').getByRole('button', { name: translations.en.cvDashboardDeleteCv, exact: true }).focus(); await page.keyboard.press('Enter');
  expect((await deletedResponse).status()).toBe(204);
  await expect(card(page, copy.name)).toHaveCount(0);
  await expect(page.getByRole('region', { name: translations.en.cvDashboardTitle, exact: true })).toBeFocused();
  expect((await page.request.get(`${apiUrl}/cv/variants/${copy.id}`)).status()).toBe(404);
  expect(await json<unknown[]>(await page.request.get(`${apiUrl}/cv/variants/${copy.id}/versions`))).toEqual([]);
  await page.reload();
  await expect(card(page, renamedName)).toBeVisible(); await expect(card(page, copy.name)).toHaveCount(0);
  expect(await json<CvVariant>(await page.request.get(`${apiUrl}/cv/variants/${original.id}`))).toEqual(renamed);
  expect(await readSource(page.request)).toEqual(sourceBefore);
  expect(await json<unknown>(await page.request.get(frozenUrl))).toEqual(frozenBefore);
  await capture(page, info, desktop, 'crud-reloaded');
  await info.attach('library-crud-readback', { body: JSON.stringify({ original, renamed, copy, duplicateWrites, frozenBefore,
    sourceUnchanged: true, frozenUnchanged: true, qualification: 'Actual HTTP rename/duplicate/delete and frozen DTO readback; held duplicate continues the real request. Frozen DTO equality is not archived PDF-byte or restore qualification.' }), contentType: 'application/json' });
});

test('[P7-04 PRES-C05 C10] concurrent rename receives ordinary409 and requires owner review before a new save', async ({ page, owner }, info) => {
  const sourceBefore = await seedSource(page, owner);
  const original = await createVariant(page.request, owner, 'Recorded conflict CV');
  await enter(page, owner);
  const writes: unknown[] = [];
  let release!: () => void;
  const held = new Promise<void>(resolve => { release = resolve; });
  await page.route(`**/api/cv/variants/${original.id}`, async route => {
    if (route.request().method() !== 'PUT') return route.continue();
    writes.push(route.request().postDataJSON()); if (writes.length === 1) await held;
    return route.continue();
  });
  await openAction(page, original.name, translations.en.cvDashboardRename);
  await page.getByRole('dialog').getByRole('textbox').fill('Unsaved rename that must not win');
  const conflictedResponse = page.waitForResponse(response => response.url() === `${apiUrl}/cv/variants/${original.id}` && response.request().method() === 'PUT');
  let intervening!: CvVariant;
  try {
    await page.getByRole('dialog').getByRole('button', { name: translations.en.cvDashboardRename, exact: true }).click();
    await expect.poll(() => writes.length).toBe(1);
    intervening = await json<CvVariant>(await page.request.put(`${apiUrl}/cv/variants/${original.id}`, { headers: owner.headers,
      data: { name: 'Recorded intervening owner change', settings: original.settings, source: 'manual', expectedVersion: original.version } }));
  } finally { release(); }
  const conflict = await conflictedResponse;
  expect(conflict.status()).toBe(409); expect(await conflict.json()).toMatchObject({ code: 'cv_revision_conflict' });
  await expect(page.getByRole('alert').filter({ hasText: 'changed elsewhere' })).toBeVisible();
  expect(writes).toHaveLength(1);
  expect(await json<CvVariant>(await page.request.get(`${apiUrl}/cv/variants/${original.id}`))).toEqual(intervening);
  await page.reload(); await expect(card(page, intervening.name)).toBeVisible();
  await openAction(page, intervening.name, translations.en.cvDashboardRename);
  await expect(page.getByRole('dialog').getByRole('textbox')).toHaveValue(intervening.name);
  await page.getByRole('dialog').getByRole('textbox').fill('Recorded rename after explicit reload and review');
  const reviewedResponse = page.waitForResponse(response => response.url() === `${apiUrl}/cv/variants/${original.id}` && response.request().method() === 'PUT');
  await page.getByRole('dialog').getByRole('button', { name: translations.en.cvDashboardRename, exact: true }).click();
  const reviewed = await json<CvVariant>(await reviewedResponse);
  expect(writes).toHaveLength(2); expect(writes[1]).toMatchObject({ expectedVersion: intervening.version, settings: intervening.settings, source: 'manual' });
  expect(reviewed.version).toBe(intervening.version + 1); expect(reviewed.settings).toEqual(intervening.settings);
  expect(await readSource(page.request)).toEqual(sourceBefore);
  await info.attach('library-ordinary-rename-conflict', { body: JSON.stringify({ original, intervening, writes, reviewed,
    qualification: 'Both saves reach the actual server; browser PUT is held while an owner-authorized API save advances its revision. No expected-failure/skip or automatic retry.' }), contentType: 'application/json' });
});

test('[P7-04 PRES-C05 C08 C12 A02] free gallery, private ownership and revoked public links retain server admission boundaries', async ({ page, owner, playwright }, info) => {
  const sourceBefore = await seedSource(page, owner);
  const original = await createVariant(page.request, owner, 'Recorded owner-private CV');
  const themes = await json<CvTheme[]>(await page.request.get(`${apiUrl}/cv/themes`));
  const locked = themes.find(theme => theme.requiresPro && !theme.available)!;
  expect(locked).toBeDefined();
  expect((await page.request.post(`${apiUrl}/cv/variants`, { headers: owner.headers,
    data: { name: 'Forbidden premium CV', settings: settings(locked.id) } })).status()).toBe(403);
  await enter(page, owner);
  const dialog = await openCreate(page);
  await dialog.getByRole('button', { name: translations.en.cvEditorAllTemplates, exact: true }).click();
  const premium = dialog.getByRole('button', { name: locked.name, exact: true });
  await expect(premium).toHaveAttribute('aria-disabled', 'true');
  await expect(premium).toHaveAttribute('tabindex', '-1');
  const selectedBefore = await dialog.locator('[aria-pressed="true"][role="button"]').getAttribute('aria-label');
  expect(selectedBefore).not.toBe(locked.name);
  await dialog.getByRole('button', { name: translations.en.cancel, exact: true }).click();
  const foreign = await playwright.request.newContext();
  const anonymous = await playwright.request.newContext();
  const admin = await playwright.request.newContext();
  try {
    const administrator = await login(admin, 'e2e@example.test');
    const foreignOwner = await login(foreign, await createOwner(admin, administrator));
    expect(await json<CvVariantSummary[]>(await foreign.get(`${apiUrl}/cv/variants`))).toEqual([]);
    const forbidden = [
      await foreign.get(`${apiUrl}/cv/variants/${original.id}`),
      await foreign.put(`${apiUrl}/cv/variants/${original.id}`, { headers: foreignOwner.headers, data: { name: 'Forbidden rename', settings: original.settings, source: 'manual', expectedVersion: original.version } }),
      await foreign.post(`${apiUrl}/cv/variants/${original.id}/duplicate`, { headers: foreignOwner.headers, data: {} }),
      await foreign.put(`${apiUrl}/cv/variants/${original.id}/public`, { headers: foreignOwner.headers, data: { isPublic: true } }),
      await foreign.post(`${apiUrl}/cv/variants/${original.id}/export-pdf`, { headers: foreignOwner.headers, data: {} }),
      await foreign.delete(`${apiUrl}/cv/variants/${original.id}`, { headers: foreignOwner.headers }),
    ];
    expect(forbidden.map(response => response.status())).toEqual([404, 404, 404, 404, 404, 404]);
    expect(await json<unknown[]>(await foreign.get(`${apiUrl}/cv/variants/${original.id}/versions`))).toEqual([]);
    expect((await anonymous.get(`${apiUrl}/cv/variants/${original.id}`)).status()).toBe(401);
    expect((await anonymous.get(`${apiUrl}/public-cv/${original.publicSlug}`)).status()).toBe(404);
    const published = await json<CvVariant>(await page.request.put(`${apiUrl}/cv/variants/${original.id}/public`, { headers: owner.headers, data: { isPublic: true } }));
    const publicResponse = await anonymous.get(`${apiUrl}/public-cv/${published.publicSlug}`);
    const publicDocument = await json<{ html: string; name: string }>(publicResponse);
    expect(publicResponse.headers()['x-robots-tag']).toBe('noindex, nofollow'); expect(publicDocument.html).toContain('CV-specific reviewed title');
    await page.reload(); await expect(card(page, original.name).getByText(translations.en.cvEditorPublic, { exact: true })).toBeVisible();
    await json<CvVariant>(await page.request.put(`${apiUrl}/cv/variants/${original.id}/public`, { headers: owner.headers, data: { isPublic: false } }));
    expect((await anonymous.get(`${apiUrl}/public-cv/${published.publicSlug}`)).status()).toBe(404);
    expect((await anonymous.get(`${apiUrl}/public-cv/${published.publicSlug}/pdf`)).status()).toBe(404);
    const republished = await json<CvVariant>(await page.request.put(`${apiUrl}/cv/variants/${original.id}/public`, { headers: owner.headers, data: { isPublic: true } }));
    expect(republished.publicSlug).not.toBe(published.publicSlug);
    expect((await anonymous.get(`${apiUrl}/public-cv/${published.publicSlug}`)).status()).toBe(404);
    expect((await anonymous.get(`${apiUrl}/public-cv/${published.publicSlug}/pdf`)).status()).toBe(404);
    expect((await anonymous.get(`${apiUrl}/public-cv/${republished.publicSlug}`)).status()).toBe(200);
    expect(await readSource(page.request)).toEqual(sourceBefore);
    await info.attach('library-server-admission', { body: JSON.stringify({ originalId: original.id, lockedTheme: locked.id,
      foreignStatuses: forbidden.map(response => response.status()), publishedSlug: published.publicSlug, republishedSlug: republished.publicSlug,
      qualification: 'Actual HTTP owner/entitlement, anonymous HTML and revoked-PDF admission only. No valid private/public PDF rendering or output-fidelity claim; public UI migration is a separate checkpoint.' }), contentType: 'application/json' });
  } finally { await foreign.dispose(); await anonymous.dispose(); await admin.dispose(); }
});

for (const status of [503, 504]) {
  test(`[P7-04 PRES-C05 C12 E08] private PDF${status} feedback does not retry or change the CV`, async ({ page, owner }, info) => {
    const sourceBefore = await seedSource(page, owner);
    const existing = await createVariant(page.request, owner, `Recorded PDF${status} CV`);
    let requests = 0;
    await page.route(`**/api/cv/variants/${existing.id}/export-pdf`, async route => {
      requests++; return route.fulfill({ status, contentType: 'application/json', body: JSON.stringify({ message: 'Controlled PDF unavailable' }) });
    });
    const sample: Sample = { language: 'nb', theme: 'dark', width: 390, height: 844 };
    await enter(page, owner, sample);
    await openAction(page, existing.name, translations.nb.cvEditorDownloadPdf, 'nb');
    await expect(page.getByRole('alert').filter({ hasText: status === 503 ? translations.nb.cvPdfBusy : translations.nb.cvPdfTimedOut })).toBeVisible();
    expect(requests).toBe(1);
    expect(await json<CvVariant>(await page.request.get(`${apiUrl}/cv/variants/${existing.id}`))).toEqual(existing);
    expect(await readSource(page.request)).toEqual(sourceBefore);
    await info.attach(`library-pdf-${status}-presentation`, { body: JSON.stringify({ requests, status,
      qualification: 'Controlled browser HTTP failure tests presentation/no automatic retry. Exporter is not invoked; this is not PDF output or actual admission qualification.' }), contentType: 'application/json' });
  });
}

test('[P7-04 PRES-C05 C08 E08] finite library and gallery width locale theme matrix keeps actions and real data reachable', async ({ page, owner }, info) => {
  test.setTimeout(180_000);
  const sourceBefore = await seedSource(page, owner);
  const longName = 'Backendutvikler — Åse Nordlys sin eiergjennomgåtte CV for dokumentert profesjonelt arbeid i norske organisasjoner';
  const longUnbrokenName = 'EiergjennomgåttDokumentertProfesjonellErfaringOgKvalifikasjoner'.repeat(3);
  const originals = [await createVariant(page.request, owner, longName), await createVariant(page.request, owner, longUnbrokenName)];
  const samples: Sample[] = [
    { language: 'nb', theme: 'light', width: 320, height: 844 },
    { language: 'en', theme: 'dark', width: 360, height: 844 },
    { language: 'nb', theme: 'dark', width: 390, height: 844 },
    { language: 'en', theme: 'light', width: 768, height: 1024 },
    { language: 'nb', theme: 'light', width: 1024, height: 768 },
    { language: 'en', theme: 'dark', width: 1280, height: 320 },
    { language: 'nb', theme: 'dark', width: 1440, height: 900 },
    { language: 'en', theme: 'light', width: 1920, height: 1080 },
  ];
  for (const sample of samples) {
    await enter(page, owner, sample);
    await expect(card(page, longName, sample.language)).toBeVisible();
    await expect(card(page, longUnbrokenName, sample.language)).toBeVisible();
    await actionButton(page, longName, sample.language).focus(); await page.keyboard.press('Enter');
    await expect(page.getByRole('menu').getByRole('menuitem', { name: translations[sample.language].cvDashboardRename, exact: true })).toBeVisible();
    await page.keyboard.press('Escape'); await expect(actionButton(page, longName, sample.language)).toBeFocused();
    await page.getByRole('heading', { level: 2, name: translations[sample.language].cvDashboardLibraryTitle, exact: true }).scrollIntoViewIfNeeded();
    await capture(page, info, sample, 'library');
    const dialog = await openCreate(page, sample.language);
    await expect(dialog.getByLabel(translations[sample.language].cvEditorName, { exact: false })).toBeFocused();
    await dialog.getByLabel(translations[sample.language].cvEditorName, { exact: false }).fill(longName);
    await dialog.getByRole('button', { name: translations[sample.language].cvEditorAllTemplates, exact: true }).click();
    await capture(page, info, sample, 'gallery');
    await dialog.getByRole('button', { name: translations[sample.language].cancel, exact: true }).focus(); await page.keyboard.press('Enter');
    await expect(page.getByRole('button', { name: translations[sample.language].cvDashboardNewCv, exact: true })).toBeFocused();
  }
  expect(await readSource(page.request)).toEqual(sourceBefore);
  for (const original of originals) expect(await json<CvVariant>(await page.request.get(`${apiUrl}/cv/variants/${original.id}`))).toEqual(original);
  await info.attach('library-finite-responsive-matrix', { body: JSON.stringify({ samples, originals,
    qualification: 'Eight balanced samples, not the complete width x theme x locale cross-product. Library and create gallery are captured separately; no document-canvas scrolling, physical touch, actual zoom or human screen-reader acceptance.' }), contentType: 'application/json' });
});