import { chromium, request } from "playwright";
import fs from "node:fs";
import path from "node:path";
import { fileURLToPath } from "node:url";

const __filename = fileURLToPath(import.meta.url);
const __dirname = path.dirname(__filename);

const stamp = new Date().toISOString().replace(/[:.]/g, "-");
const runId = `defect-ledger-${Date.now()}`;
const webBase = process.env.DEFECT_LEDGER_WEB_URL || "http://127.0.0.1:3005";
const apiBase = process.env.DEFECT_LEDGER_API_URL || "http://127.0.0.1:8000/api/v1";
const healthUrl = process.env.DEFECT_LEDGER_HEALTH_URL || "http://127.0.0.1:8000/health";
const adminPassword = process.env.AI_CONTRACT_ADMIN_PASSWORD || "123456";
const artifactDir =
  process.env.DEFECT_LEDGER_ARTIFACT_DIR ||
  path.resolve(__dirname, "..", "..", "..", "project-docs", "qa-artifacts", "defect-ledger-regression", stamp);

fs.mkdirSync(artifactDir, { recursive: true });

const FORMAL_DEFECTS = [
  { id: 1, title: "管理员初始化后仍无法登录" },
  { id: 2, title: "member 无法下载自己生成的合同" },
  { id: 3, title: "审查详情页自动触发 401 报告下载" },
  { id: 4, title: "审查列表页下载报告不触发真实下载" },
  { id: 5, title: "无效 review 详情缺少清晰 404 空态" },
  { id: 6, title: "无效 contract 详情缺少清晰 404 空态" },
  { id: 7, title: "前端仍接受 PNG 进入已选文件状态" },
  { id: 8, title: "Chat 页面出现矛盾的未返回回答提示" },
  { id: 9, title: "知识库旧入口路由与权限预期不一致" },
  { id: 10, title: "PDF 噪声内容被当作有效审查文本" },
  { id: 11, title: "错误登录提示仍为英文" },
  { id: 12, title: "登录页暴露默认管理员初始化入口" },
  { id: 13, title: "member 误入仅管理员文件中心" },
  { id: 14, title: "中文按钮文本被自动插空格" },
  { id: 15, title: "PNG 异常文件可直接提交审查" },
  { id: 16, title: "EXE 异常文件可直接提交审查" },
  { id: 17, title: "慢网抖动期间提交按钮未锁定" },
];

const results = [];
const state = {
  api: null,
  browser: null,
  admin: null,
  member: null,
  reviewId: null,
  contractId: null,
};

function screenshotPath(name) {
  return path.join(artifactDir, `${name}.png`);
}

function apiUrl(route) {
  return `${apiBase.replace(/\/$/, "")}${route}`;
}

function assert(condition, message, details = undefined) {
  if (!condition) {
    const error = new Error(message);
    error.details = details;
    throw error;
  }
}

function buildCoverage(resultsList) {
  return FORMAL_DEFECTS.map((defect) => {
    const linkedSteps = resultsList.filter((item) => Array.isArray(item.covers) && item.covers.includes(defect.id));
    return {
      id: defect.id,
      title: defect.title,
      step_ids: linkedSteps.map((item) => item.id),
      status: linkedSteps.length > 0 && linkedSteps.every((item) => item.status === "PASS") ? "PASS" : "FAIL",
    };
  });
}

async function step(id, title, covers, fn) {
  const startedAt = new Date().toISOString();
  const started = Date.now();
  try {
    const details = await fn();
    const item = { id, title, covers, status: "PASS", duration_ms: Date.now() - started, started_at: startedAt, details: details || {} };
    results.push(item);
    console.log(`PASS ${id} ${title}`);
    return item;
  } catch (error) {
    const item = {
      id,
      title,
      covers,
      status: "FAIL",
      duration_ms: Date.now() - started,
      started_at: startedAt,
      error: error.message,
      details: error.details || {},
    };
    results.push(item);
    console.error(`FAIL ${id} ${title}: ${error.message}`);
    return item;
  }
}

async function apiRequest(method, route, options = {}) {
  const headers = {
    ...(options.authToken ? { Authorization: `Bearer ${options.authToken}` } : {}),
    ...(options.headers || {}),
  };
  const response = await state.api[method](apiUrl(route), { ...options, headers });
  const text = await response.text();
  let body = null;
  if (text) {
    try {
      body = JSON.parse(text);
    } catch {
      body = text;
    }
  }
  return { response, body, text };
}

function expectOk(payload, label) {
  assert(payload.response.status() >= 200 && payload.response.status() < 300, `${label} HTTP ${payload.response.status()}`, { body: payload.body });
  if (payload.body && typeof payload.body === "object" && "code" in payload.body) {
    assert(payload.body.code === 0, `${label} API code ${payload.body.code}`, { body: payload.body });
  }
}

async function login(account, password) {
  const payload = await apiRequest("post", "/auth/login", { data: { account, password } });
  expectOk(payload, `login ${account}`);
  return payload.body.data;
}

async function createAuthenticatedContext(userSession) {
  const context = await state.browser.newContext({ viewport: { width: 1440, height: 1100 }, acceptDownloads: true });
  await context.addInitScript(
    ({ token, user }) => {
      window.localStorage.setItem("access_token", token);
      window.localStorage.setItem("auth-store", JSON.stringify({ state: { accessToken: token, currentUser: user }, version: 0 }));
    },
    { token: userSession.access_token, user: userSession.user },
  );
  return context;
}

async function createReview() {
  const create = await apiRequest("post", "/reviews", {
    authToken: state.admin.access_token,
    multipart: {
      text: `${runId} 审查样本\n自动续约\n免责\n付款`,
      review_as: "party_a",
      contract_type: "service",
    },
  });
  expectOk(create, "create review");
  state.reviewId = create.body.data.id;
  return state.reviewId;
}

async function createMemberContract() {
  const username = `${runId}-member@example.com`;
  const password = "123456";
  const register = await apiRequest("post", "/auth/register", {
    data: { username, password, display_name: "Defect Ledger Member" },
  });
  expectOk(register, "register member");
  state.member = await login(username, password);
  const templates = await apiRequest("get", "/contracts/templates", { authToken: state.member.access_token });
  expectOk(templates, "member templates");
  const template = templates.body.data[0];
  const values = {};
  for (const variable of template.variables || []) {
    values[variable.name] = `member-${variable.name}`;
  }
  const generate = await apiRequest("post", "/contracts/generate", {
    authToken: state.member.access_token,
    multipart: {
      template_id: template.id,
      variable_values_json: JSON.stringify(values),
      export_format: "txt",
    },
  });
  expectOk(generate, "member generate contract");
  state.contractId = generate.body.data.id;
  return state.contractId;
}

async function run() {
  state.api = await request.newContext();
  state.browser = await chromium.launch({ headless: true });

  await step("ENV-001", "frontend and backend health", [], async () => {
    const frontend = await state.api.get(`${webBase}/login`);
    const health = await state.api.get(healthUrl);
    assert(frontend.status() === 200, `frontend /login status ${frontend.status()}`);
    assert(health.status() === 200, `backend /health status ${health.status()}`);
    state.admin = await login("admin@example.com", adminPassword);
    return { webBase, apiBase, healthUrl };
  });

  await step("AUTH-UX-001", "login page hides seed admin and shows chinese error", [1, 11, 12], async () => {
    const page = await state.browser.newPage({ viewport: { width: 1365, height: 900 } });
    await page.goto(`${webBase}/login`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1200);
    const initialBody = await page.locator("body").innerText();
    assert(!initialBody.includes("初始化默认管理员"), "seed admin entry should be hidden on non-local login page", initialBody.slice(0, 1200));
    await page.getByLabel("账号").fill("admin@example.com");
    await page.getByLabel("密码").fill("wrong-password");
    await page.getByRole("button", { name: /登录/ }).click();
    await page.waitForTimeout(1000);
    const finalBody = await page.locator("body").innerText();
    await page.screenshot({ path: screenshotPath("auth-login-ux"), fullPage: true });
    assert(finalBody.includes("账号或密码错误"), "wrong password should show chinese error", finalBody.slice(0, 1400));
    await page.close();
    return { screenshot: "auth-login-ux.png" };
  });

  await step("ROUTE-UX-001", "invalid detail pages and legacy knowledge route are clear", [5, 6, 9], async () => {
    const context = await createAuthenticatedContext(state.admin);
    const page = await context.newPage();
    await page.goto(`${webBase}/reviews/not-a-real-id`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1200);
    let body = await page.locator("body").innerText();
    assert(body.includes("审查记录不存在或已被删除"), "invalid review detail should show clear empty state", body.slice(0, 1500));
    await page.goto(`${webBase}/contracts/not-a-real-id`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1200);
    body = await page.locator("body").innerText();
    assert(body.includes("合同不存在或已被删除"), "invalid contract detail should show clear empty state", body.slice(0, 1500));
    await page.goto(`${webBase}/knowledge?tab=all`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1200);
    assert(page.url().includes("/knowledge-bases"), "legacy knowledge route should redirect to /knowledge-bases", { url: page.url() });
    await page.screenshot({ path: screenshotPath("route-ux"), fullPage: true });
    await context.close();
    return { screenshot: "route-ux.png", finalUrl: page.url() };
  });

  await step("REVIEW-DOWNLOAD-001", "review detail does not auto-401 and list download works", [3, 4], async () => {
    const reviewId = await createReview();
    const context = await createAuthenticatedContext(state.admin);
    const page = await context.newPage();
    const reportFailures = [];
    page.on("response", async (response) => {
      if (response.url().includes(`/reviews/${reviewId}/report/download`) && response.status() >= 400) {
        reportFailures.push({ url: response.url(), status: response.status() });
      }
    });
    await page.goto(`${webBase}/reviews/${reviewId}`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(2200);
    assert(reportFailures.length === 0, "review detail should not auto-trigger unauthorized report download", { reportFailures });
    await page.goto(`${webBase}/reviews`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1500);
    const [download] = await Promise.all([
      page.waitForEvent("download", { timeout: 12000 }),
      page.getByRole("button", { name: "下载报告" }).first().click(),
    ]);
    const file = path.join(artifactDir, download.suggestedFilename());
    await download.saveAs(file);
    assert(fs.statSync(file).size > 0, "review list download should produce non-empty file");
    await page.screenshot({ path: screenshotPath("review-download"), fullPage: true });
    await context.close();
    return { screenshot: "review-download.png", file };
  });

  await step("CHAT-STATE-001", "chat page does not show contradictory empty-answer copy", [8], async () => {
    const reviewPayload = {
      reviewId: state.reviewId,
      prompt: "请总结当前审查结果，并给出最值得优先处理的修改建议。",
      metadata: {
        reviewTitle: "Defect Ledger Review Context",
        reviewStatus: "completed",
        contractType: "service",
        overallRisk: "high",
        reviewOpinion: "请围绕高风险项输出结构化建议。",
        focusLabel: "高风险项",
        actionLabel: "生成修改清单",
        focusType: "risk_item",
      },
    };
    const context = await createAuthenticatedContext(state.admin);
    const page = await context.newPage();
    await page.goto(`${webBase}/chat?review=${encodeURIComponent(JSON.stringify(reviewPayload))}`, { waitUntil: "domcontentloaded" });
    await page.waitForRequest((request) => request.url().includes("/api/v1/chat/stream"), { timeout: 20000 });
    await page.waitForTimeout(4200);
    const body = await page.locator("body").innerText();
    await page.screenshot({ path: screenshotPath("chat-state"), fullPage: true });
    assert(!body.includes("本轮未返回回答内容"), "chat page should not show contradictory empty-answer copy", body.slice(-1800));
    await context.close();
    return { screenshot: "chat-state.png" };
  });

  await step("PDF-NOISE-001", "noisy pdf content is rejected instead of creating a fake review result", [10], async () => {
    const noisyPdf = Buffer.from(
      [
        "%PDF-1.4",
        "1 0 obj",
        "<< /Type /Catalog /Pages 2 0 R >>",
        "endobj",
        "2 0 obj",
        "<< /Type /Pages /Count 1 /Kids [3 0 R] >>",
        "endobj",
        "3 0 obj",
        "<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents 4 0 R >>",
        "endobj",
        "4 0 obj",
        "<< /Length 44 >>",
        "stream",
        "BT /F1 12 Tf 72 720 Td (Catalog Pages Type Parent) Tj ET",
        "endstream",
        "endobj",
        "trailer",
        "<< /Root 1 0 R >>",
        "startxref",
        "0",
        "%%EOF",
      ].join("\n"),
      "utf8",
    );
    const response = await apiRequest("post", "/reviews", {
      authToken: state.admin.access_token,
      multipart: {
        review_as: "party_a",
        file: { name: `${runId}-noise.pdf`, mimeType: "application/pdf", buffer: noisyPdf },
      },
    });
    assert(response.response.status() === 200, "noisy pdf business rejection should still return structured response", {
      status: response.response.status(),
      body: response.body,
    });
    assert(response.body?.code === 40002, "noisy pdf should return 40002", { body: response.body });
    assert(
      String(response.body?.message || "").includes("无法从上传文件中提取可审查文本"),
      "noisy pdf should return extraction guidance",
      { body: response.body },
    );
    return { http_status: response.response.status(), body: response.body };
  });

  await step("UPLOAD-GUARD-001", "invalid upload formats are rejected and duplicate submit is locked", [7, 15, 16, 17], async () => {
    const context = await createAuthenticatedContext(state.admin);
    const page = await context.newPage();
    await page.goto(`${webBase}/review`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1200);

    await page.locator("input[type=file]").setInputFiles({
      name: `${runId}.png`,
      mimeType: "image/png",
      buffer: Buffer.from("png"),
    });
    await page.waitForTimeout(600);
    let body = await page.locator("body").innerText();
    assert(body.includes("仅支持 PDF / DOCX / TXT 文件"), "png upload should be rejected in UI", body.slice(0, 1600));
    assert(!body.includes(`${runId}.png`), "rejected png should not remain selected", body.slice(0, 1600));

    const pngResponse = await apiRequest("post", "/reviews", {
      authToken: state.admin.access_token,
      multipart: {
        review_as: "party_a",
        file: { name: `${runId}.png`, mimeType: "image/png", buffer: Buffer.from("png") },
      },
    });
    assert(pngResponse.response.status() === 400, "png upload should be rejected by backend", { status: pngResponse.response.status(), body: pngResponse.body });

    const exeResponse = await apiRequest("post", "/reviews", {
      authToken: state.admin.access_token,
      multipart: {
        review_as: "party_a",
        file: { name: `${runId}.exe`, mimeType: "application/x-msdownload", buffer: Buffer.from("MZ") },
      },
    });
    assert(exeResponse.response.status() === 400, "exe upload should be rejected by backend", { status: exeResponse.response.status(), body: exeResponse.body });

    let reviewRequestCount = 0;
    await page.route("**/api/v1/reviews", async (route) => {
      reviewRequestCount += 1;
      await new Promise((resolve) => setTimeout(resolve, 1800));
      await route.continue();
    });
    await page.getByPlaceholder("可直接粘贴合同文本；如同时上传文件，系统会合并文本后一起审查。").fill(`${runId} duplicate guard text`);
    const submitButton = page.getByRole("button", { name: "提交审查" });
    await submitButton.click();
    await page.waitForTimeout(120);
    const disabledAfterClick = await submitButton.isDisabled();
    if (!disabledAfterClick) {
      await submitButton.click({ trial: false });
    }
    await page.waitForTimeout(2600);
    assert(reviewRequestCount === 1, "duplicate submit should emit only one review request", { reviewRequestCount, disabledAfterClick });
    await page.screenshot({ path: screenshotPath("upload-guard"), fullPage: true });
    await context.close();
    return { screenshot: "upload-guard.png", reviewRequestCount, disabledAfterClick };
  });

  await step("MEMBER-CONTRACT-001", "member can download own contract and does not see file-center trap", [2, 13], async () => {
    const contractId = await createMemberContract();
    const apiDownload = await apiRequest("get", `/contracts/${contractId}/download`, {
      authToken: state.member.access_token,
    });
    assert(apiDownload.response.status() === 200, "member api download should succeed", { status: apiDownload.response.status(), body: apiDownload.body });

    const context = await createAuthenticatedContext(state.member);
    const page = await context.newPage();
    await page.goto(`${webBase}/contracts/${contractId}`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1500);
    let body = await page.locator("body").innerText();
    assert(!body.includes("查看文件资产"), "member contract detail should not expose file center button", body.slice(0, 1600));

    const [download] = await Promise.all([
      page.waitForEvent("download", { timeout: 12000 }),
      page.getByRole("button", { name: "下载合同文件" }).click(),
    ]);
    const file = path.join(artifactDir, download.suggestedFilename());
    await download.saveAs(file);
    assert(fs.statSync(file).size > 0, "member contract detail download should produce non-empty file");

    await page.goto(`${webBase}/contracts`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1500);
    body = await page.locator("body").innerText();
    assert(!body.includes("查看文件资产"), "member contract history should not expose file center button", body.slice(0, 1600));
    await page.screenshot({ path: screenshotPath("member-contract"), fullPage: true });
    await context.close();
    return { screenshot: "member-contract.png", file };
  });

  await step("TEXT-UX-001", "button labels do not expose split chinese spacing", [14], async () => {
    const context = await createAuthenticatedContext(state.admin);
    const page = await context.newPage();
    await page.goto(`${webBase}/contracts`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1400);
    let body = await page.locator("body").innerText();
    assert(!body.includes("选 择"), "contracts page should not show split spacing for 选择", body.slice(0, 1800));
    await page.goto(`${webBase}/reviews`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1400);
    body = await page.locator("body").innerText();
    assert(!body.includes("详 情"), "reviews page should not show split spacing for 详情", body.slice(0, 1800));
    assert(!body.includes("下 载"), "reviews page should not show split spacing for 下载", body.slice(0, 1800));
    assert(!body.includes("重 置"), "reviews page should not show split spacing for 重置", body.slice(0, 1800));
    await page.screenshot({ path: screenshotPath("text-ux"), fullPage: true });
    await context.close();
    return { screenshot: "text-ux.png" };
  });

  await step("COVERAGE-001", "all 17 formal defects are covered by passing regression checks", [], async () => {
    const coverage = buildCoverage(results);
    const missing = coverage.filter((item) => item.status !== "PASS");
    assert(missing.length === 0, "formal defect coverage is incomplete", { missing, coverage });
    return {
      total_defects: coverage.length,
      passed_defects: coverage.filter((item) => item.status === "PASS").length,
      coverage,
    };
  });

  const defectCoverage = buildCoverage(results);

  const summary = {
    run_id: runId,
    web_base: webBase,
    api_base: apiBase,
    health_url: healthUrl,
    artifact_dir: artifactDir,
    total: results.length,
    passed: results.filter((item) => item.status === "PASS").length,
    failed: results.filter((item) => item.status === "FAIL").length,
    formal_defects_total: FORMAL_DEFECTS.length,
    formal_defects_passed: defectCoverage.filter((item) => item.status === "PASS").length,
    defect_coverage: defectCoverage,
    results,
  };
  fs.writeFileSync(path.join(artifactDir, "defect-ledger-regression-summary.json"), JSON.stringify(summary, null, 2), "utf8");
  fs.writeFileSync(
    path.join(artifactDir, "defect-ledger-regression-summary.md"),
    [
      "# Defect Ledger Regression",
      "",
      `- Run ID: \`${runId}\``,
      `- Web: \`${webBase}\``,
      `- API: \`${apiBase}\``,
      `- Passed: ${summary.passed}/${summary.total}`,
      `- Formal Defects Passed: ${summary.formal_defects_passed}/${summary.formal_defects_total}`,
      "",
      "| ID | Status | Title |",
      "|---|---|---|",
      ...results.map((item) => `| ${item.id} | ${item.status} | ${item.title.replace(/\|/g, "/")} |`),
      "",
      "## Formal Defect Coverage",
      "",
      "| Defect | Status | Covered By | Title |",
      "|---|---|---|---|",
      ...defectCoverage.map(
        (item) => `| ${item.id} | ${item.status} | ${(item.step_ids.join(", ") || "N/A").replace(/\|/g, "/")} | ${item.title.replace(/\|/g, "/")} |`,
      ),
    ].join("\n"),
    "utf8",
  );
  console.log(JSON.stringify(summary, null, 2));

  await state.browser.close().catch(() => undefined);
  await state.api.dispose().catch(() => undefined);
  if (summary.failed > 0) {
    process.exitCode = 1;
  }
}

run().catch(async (error) => {
  const summary = {
    run_id: runId,
    web_base: webBase,
    api_base: apiBase,
    health_url: healthUrl,
    artifact_dir: artifactDir,
    total: results.length + 1,
    passed: results.filter((item) => item.status === "PASS").length,
    failed: results.filter((item) => item.status === "FAIL").length + 1,
    formal_defects_total: FORMAL_DEFECTS.length,
    defect_coverage: buildCoverage(results),
    results: [
      ...results,
      {
        id: "RUNNER",
        title: "unhandled runner error",
        status: "FAIL",
        error: error.message,
        details: error.details || {},
      },
    ],
  };
  fs.writeFileSync(path.join(artifactDir, "defect-ledger-regression-summary.json"), JSON.stringify(summary, null, 2), "utf8");
  console.error(JSON.stringify(summary, null, 2));
  await state.browser?.close().catch(() => undefined);
  await state.api?.dispose().catch(() => undefined);
  process.exit(1);
});