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 = `phase2-auto-${Date.now()}`;
const webBase = process.env.PHASE2_WEB_URL || "http://127.0.0.1:3005";
const apiBase = process.env.PHASE2_API_URL || "http://127.0.0.1:8000/api/v1";
const healthUrl = process.env.PHASE2_HEALTH_URL || "http://127.0.0.1:8000/health";
const adminPassword = process.env.AI_CONTRACT_ADMIN_PASSWORD || "123456";
const artifactDir =
  process.env.PHASE2_ARTIFACT_DIR ||
  path.resolve(__dirname, "..", "..", "..", "project-docs", "qa-artifacts", "phase2-closed-loop", stamp);

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

const results = [];
const state = {
  admin: null,
  browser: null,
  contexts: [],
  api: null,
  reviewId: null,
  knowledgeBaseId: null,
  failedDocumentId: null,
};

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

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

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

async function step(id, title, fn) {
  const startedAt = new Date().toISOString();
  const started = Date.now();
  try {
    const details = await fn();
    const item = {
      id,
      title,
      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,
      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 },
  );
  state.contexts.push(context);
  return context;
}

async function createReview() {
  const text = [
    `${runId} 阶段2审查生命周期样本。`,
    "合同约定自动续约，并包含免责、付款条件另行协商和50%违约金。",
    "请重点关注风险解释、后续问答和合同生成衔接。",
  ].join("\n");
  const create = await apiRequest("post", "/reviews", {
    authToken: state.admin.access_token,
    multipart: { text, review_as: "party_a", contract_type: "procurement" },
  });
  expectOk(create, "create review");
  state.reviewId = create.body.data.id;
  return create.body.data.id;
}

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()}`);
    return { webBase, apiBase, healthUrl, artifactDir };
  });

  await step("AUTH-001", "admin login", async () => {
    state.admin = await login("admin@example.com", adminPassword);
    assert(state.admin.user.role === "admin", "admin role mismatch", state.admin.user);
    return { user: state.admin.user.username, role: state.admin.user.role };
  });

  await step("REVIEW-LC-001", "review lifecycle fields and report readiness", async () => {
    const reviewId = await createReview();
    const detail = await apiRequest("get", `/reviews/${reviewId}`, { authToken: state.admin.access_token });
    const result = await apiRequest("get", `/reviews/${reviewId}/result`, { authToken: state.admin.access_token });
    expectOk(detail, "review detail");
    expectOk(result, "review result");
    assert(detail.body.data.current_stage === "report", "review current stage should be report", detail.body.data);
    assert(detail.body.data.parse_status === "completed", "parse_status should be completed", detail.body.data);
    assert(detail.body.data.report_status === "ready", "report_status should be ready", detail.body.data);
    assert(detail.body.data.next_action?.includes("审查助手"), "review next_action should point to copilot", detail.body.data);
    assert(result.body.data.risk_summary.overall === "high", "risk summary should be high", result.body.data);
    return {
      review_id: reviewId,
      lifecycle: {
        current_stage: detail.body.data.current_stage,
        parse_status: detail.body.data.parse_status,
        review_status: detail.body.data.review_status,
        report_status: detail.body.data.report_status,
      },
      risk_summary: result.body.data.risk_summary,
    };
  });

  await step("KB-RETRY-001", "knowledge document retry and replacement file closes lifecycle", async () => {
    const create = await apiRequest("post", "/knowledge-bases", {
      authToken: state.admin.access_token,
      multipart: { name: `${runId} KB`, description: "Phase 2 retry lifecycle" },
    });
    expectOk(create, "create knowledge base");
    state.knowledgeBaseId = create.body.data.id;

    const failed = await apiRequest("post", `/knowledge-bases/${state.knowledgeBaseId}/documents`, {
      authToken: state.admin.access_token,
      multipart: {
        file: { name: `${runId}-empty.txt`, mimeType: "text/plain", buffer: Buffer.from("") },
      },
    });
    expectOk(failed, "upload failed document");
    state.failedDocumentId = failed.body.data.id;
    assert(failed.body.data.status === "failed", "empty document should fail", failed.body.data);

    const retryWithoutFile = await apiRequest("post", `/knowledge-bases/${state.knowledgeBaseId}/documents/${state.failedDocumentId}/retry`, {
      authToken: state.admin.access_token,
      multipart: { note: "retry without replacement" },
    });
    expectOk(retryWithoutFile, "retry without file");
    assert(retryWithoutFile.body.data.status === "failed", "retry without source should remain failed", retryWithoutFile.body.data);
    const retryGuidance = [
      retryWithoutFile.body.data.status_detail,
      retryWithoutFile.body.data.next_action,
      retryWithoutFile.body.data.error_message,
    ]
      .filter(Boolean)
      .join(" ");
    assert(retryGuidance.includes("重新上传"), "retry should explain reupload", retryWithoutFile.body.data);

    const replacement = await apiRequest("post", `/knowledge-bases/${state.knowledgeBaseId}/documents/${state.failedDocumentId}/retry`, {
      authToken: state.admin.access_token,
      multipart: {
        note: "retry with replacement",
        file: {
          name: `${runId}-replacement.txt`,
          mimeType: "text/plain",
          buffer: Buffer.from("阶段2知识库替换文档：付款、保密、违约责任和自动续约。", "utf8"),
        },
      },
    });
    expectOk(replacement, "retry with replacement file");
    assert(replacement.body.data.id === state.failedDocumentId, "replacement retry should keep document id", replacement.body.data);
    assert(replacement.body.data.status === "indexed", "replacement retry should index document", replacement.body.data);
    assert(replacement.body.data.index_status === "completed", "replacement retry index_status mismatch", replacement.body.data);

    const audits = await apiRequest("get", "/audit-logs?page=1&page_size=10&action=retry_knowledge_document", {
      authToken: state.admin.access_token,
    });
    expectOk(audits, "audit retry_knowledge_document");
    assert(audits.body.data.items.length >= 1, "retry audit event missing", audits.body.data);
    return {
      kb_id: state.knowledgeBaseId,
      document_id: state.failedDocumentId,
      retry_without_file_status: retryWithoutFile.body.data.status,
      replacement_status: replacement.body.data.status,
      retry_audit_total: audits.body.data.total,
    };
  });

  await step("BROWSER-REVIEW-001", "review detail links to chat and contract context", async () => {
    const context = await createAuthenticatedContext(state.admin);
    const page = await context.newPage();
    await page.goto(`${webBase}/reviews/${state.reviewId}`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1600);
    const body = await page.locator("body").innerText();
    assert(body.includes("QUICK ACTIONS") || body.includes("围绕当前审查结果"), "review detail quick actions missing", body.slice(0, 800));
    assert(body.includes("用审查结果准备合同生成"), "contract context action missing", body.slice(0, 1200));

    const chatHref = await page.locator('a:has-text("生成修改清单")').first().getAttribute("href");
    assert(chatHref?.includes("/chat?review="), "chat quick action should carry review context", { chatHref });
    await page.goto(new URL(chatHref, webBase).toString(), { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(2000);
    await page.screenshot({ path: screenshotPath("review-chat-context-followup"), fullPage: true });
    const chatBody = await page.locator("body").innerText();
    assert(chatBody.includes("法律问答") || chatBody.includes("审查助手"), "chat page should open from review context", chatBody.slice(0, 1000));

    await page.goto(`${webBase}/reviews/${state.reviewId}`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1000);
    const contractHref = await page.locator('a:has-text("用审查结果准备合同生成")').first().getAttribute("href");
    assert(contractHref?.includes("/contracts?review="), "contract action should carry review context", { contractHref });
    await page.goto(new URL(contractHref, webBase).toString(), { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1600);
    const contractBody = await page.locator("body").innerText();
    await page.screenshot({ path: screenshotPath("contract-review-context-consumed"), fullPage: true });
    assert(page.url().includes("/contracts?review="), "contract context URL missing review payload", { url: page.url() });
    assert(contractBody.includes("已接收审查上下文") || contractBody.includes("正在消费审查上下文"), "contract page did not consume review context", contractBody.slice(0, 1000));
    return {
      chat_href_contains_review: chatHref.includes("/chat?review="),
      contract_url_contains_review: page.url().includes("/contracts?review="),
      screenshots: ["review-chat-context-followup.png", "contract-review-context-consumed.png"],
    };
  });

  await step("BROWSER-KB-001", "knowledge base failed document exposes retry action", async () => {
    const failedAgain = await apiRequest("post", `/knowledge-bases/${state.knowledgeBaseId}/documents`, {
      authToken: state.admin.access_token,
      multipart: {
        file: { name: `${runId}-retry-ui-empty.txt`, mimeType: "text/plain", buffer: Buffer.from("") },
      },
    });
    expectOk(failedAgain, "upload UI failed document");

    const context = await createAuthenticatedContext(state.admin);
    const page = await context.newPage();
    await page.goto(`${webBase}/knowledge-bases`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(2200);
    let body = await page.locator("body").innerText();
    assert(body.includes("重试处理"), "retry button should be visible for failed document", body.slice(-1400));
    await page.getByText("重试处理").first().click();
    await page.waitForTimeout(1800);
    body = await page.locator("body").innerText();
    await page.screenshot({ path: screenshotPath("kb-retry-action-visible"), fullPage: true });
    assert(body.includes("重新上传"), "retry result should explain reupload path", body.slice(-1400));
    const disabledLinks = await page.locator("a.disabled-link[aria-disabled='true']").count();
    assert(disabledLinks >= 2, "failed document chat actions should remain disabled", { disabledLinks });
    return { screenshot: "kb-retry-action-visible.png", disabled_links: disabledLinks };
  });

  await step("BROWSER-HOME-001", "home cockpit exposes delivery workbench", async () => {
    const context = await createAuthenticatedContext(state.admin);
    const page = await context.newPage();
    await page.goto(`${webBase}/`, { waitUntil: "domcontentloaded" });
    await page.waitForTimeout(1600);
    await page.screenshot({ path: screenshotPath("home-delivery-cockpit"), fullPage: true });
    const body = await page.locator("body").innerText();
    assert(body.includes("优先处理摘要"), "home priority summary missing", body.slice(0, 1400));
    assert(body.includes("运营摘要"), "home operations summary missing", body.slice(0, 1400));
    assert(body.includes("管理员高频入口"), "home admin workbench missing", body.slice(0, 1800));
    return { screenshot: "home-delivery-cockpit.png" };
  });
}

async function finalize() {
  for (const context of state.contexts) {
    await context.close().catch(() => undefined);
  }
  if (state.browser) {
    await state.browser.close().catch(() => undefined);
  }
  if (state.api) {
    await state.api.dispose().catch(() => undefined);
  }

  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,
    results,
  };
  fs.writeFileSync(path.join(artifactDir, "phase2-closed-loop-summary.json"), JSON.stringify(summary, null, 2), "utf8");
  const markdown = [
    "# Phase 2 Closed Loop E2E",
    "",
    `- Run ID: \`${runId}\``,
    `- Web: \`${webBase}\``,
    `- API: \`${apiBase}\``,
    `- Passed: ${summary.passed}/${summary.total}`,
    "",
    "| ID | Status | Title | Duration |",
    "|---|---|---|---:|",
    ...results.map((item) => `| ${item.id} | ${item.status} | ${item.title.replace(/\|/g, "/")} | ${item.duration_ms}ms |`),
    "",
  ].join("\n");
  fs.writeFileSync(path.join(artifactDir, "phase2-closed-loop-summary.md"), markdown, "utf8");
  console.log(JSON.stringify(summary, null, 2));
  if (summary.failed > 0) {
    process.exitCode = 1;
  }
}

run()
  .catch((error) => {
    results.push({
      id: "RUNNER",
      title: "unhandled runner error",
      status: "FAIL",
      duration_ms: 0,
      started_at: new Date().toISOString(),
      error: error.message,
    });
    process.exitCode = 1;
  })
  .finally(finalize);