#!/usr/bin/env node
"use strict";

const assert = require("node:assert");
const fs = require("node:fs");
const path = require("node:path");
const { chromium } = require("playwright");

const BASE_URL = (process.env.MNOTE_WEB_SMOKE_BASE_URL || "http://127.0.0.1:3000").replace(/\/+$/, "");
const TASK772_RESULT_PATH = path.join(process.cwd(), "tmp", "task772-weknora-ingest-search-open-reference-e2e", "result.json");
const OUTPUT_DIR = path.join(process.cwd(), "tmp", "task784-weknora-kb-settings-browser-smoke");
const RESULT_PATH = path.join(OUTPUT_DIR, "result.json");
const SCREENSHOT_PATH = path.join(OUTPUT_DIR, "weknora-kb-settings.png");
const UI_TIMEOUT_MS = Number(process.env.MNOTE_SMOKE_UI_TIMEOUT_MS || 30_000);
const CHROMIUM_EXECUTABLE_PATH = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH
  || ["/usr/bin/chromium-browser", "/usr/bin/google-chrome-stable", "/usr/bin/google-chrome", "/snap/bin/chromium", "/usr/bin/chromium"]
    .find((candidate) => fs.existsSync(candidate));

function loadTask772Result() {
  assert(fs.existsSync(TASK772_RESULT_PATH), `缺少 task772 真实入库结果: ${TASK772_RESULT_PATH}`);
  return JSON.parse(fs.readFileSync(TASK772_RESULT_PATH, "utf8"));
}

async function signIn(context) {
  const response = await context.request.post(`${BASE_URL}/api/auth`, {
    data: {
      action: "auth:signIn",
      args: {
        provider: "password",
        params: {
          email: "mnote.e2e@example.com",
          password: process.env.MNOTE_E2E_PASSWORD || "MnoteE2E123!",
          flow: "signIn",
        },
      },
    },
    timeout: UI_TIMEOUT_MS,
  });
  assert(response.ok(), `登录失败: ${response.status()} ${await response.text()}`);
}

async function main() {
  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
  const fixture = loadTask772Result();
  assert.equal(fixture.provider, "weknora", `task772 provider 不是 weknora: ${JSON.stringify(fixture, null, 2).slice(0, 1200)}`);
  assert(fixture.rootUri && fixture.workspaceId && fixture.sourcePath && fixture.marker, "task772 结果缺少 rootUri/workspaceId/sourcePath/marker");

  const browser = await chromium.launch({
    headless: true,
    ...(CHROMIUM_EXECUTABLE_PATH ? { executablePath: CHROMIUM_EXECUTABLE_PATH } : {}),
  });
  const context = await browser.newContext({ viewport: { width: 1360, height: 900 } });
  const page = await context.newPage();

  try {
    await signIn(context);
    const url = new URL(`${BASE_URL}/`);
    url.searchParams.set("sourceKind", "local_folder");
    url.searchParams.set("rootUri", fixture.rootUri);
    url.searchParams.set("workspaceId", fixture.workspaceId);
    url.searchParams.set("treeView", "filetree");
    await page.goto(url.toString(), { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });

    await page.locator('[data-testid="mnote-knowledge-rag-settings-toggle"]').click({ timeout: UI_TIMEOUT_MS });
    const panel = page.locator('[data-testid="mnote-weknora-knowledge-settings-panel"]');
    await panel.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    await page.locator('[data-knowledge-rag-action="filter-sources"][data-knowledge-rag-filter="all"]').click({ timeout: UI_TIMEOUT_MS });

    const sourceRow = page.locator(`[data-knowledge-rag-source-row="true"][data-knowledge-rag-source-path="${fixture.sourcePath}"]`).first();
    await sourceRow.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    await sourceRow.locator('[data-knowledge-rag-action="open-source-reference"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    await sourceRow.locator('[data-knowledge-rag-action="delete-source"][data-knowledge-rag-delete-local-file-policy="preserve-local-file"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });

    const kbSummary = panel.locator('[data-testid="mnote-weknora-kb-summary"]');
    await kbSummary.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    const kbIds = await kbSummary.getAttribute("data-knowledge-rag-kb-ids");
    assert(String(kbIds || "").includes(fixture.providerKnowledgeBaseId), `KB summary 未包含 task772 KB id: ${kbIds}`);

    await panel.locator('[data-kb-rag-tab="search"]').click({ timeout: UI_TIMEOUT_MS });
    await panel.locator('[data-kb-rag-search-input]').fill(fixture.marker, { timeout: UI_TIMEOUT_MS });
    await panel.locator('[data-kb-rag-action="search"]').click({ timeout: UI_TIMEOUT_MS });
    const searchResult = panel.locator(`[data-kb-rag-search-result="true"][data-knowledge-rag-source-path="${fixture.sourcePath}"]`).first();
    await searchResult.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    await searchResult.locator('[data-knowledge-rag-action="open-source-reference"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });

    await page.screenshot({ path: SCREENSHOT_PATH, fullPage: true });
    const result = {
      ok: true,
      baseUrl: BASE_URL,
      rootUri: fixture.rootUri,
      workspaceId: fixture.workspaceId,
      sourcePath: fixture.sourcePath,
      providerKnowledgeBaseId: fixture.providerKnowledgeBaseId,
      providerKnowledgeId: fixture.providerKnowledgeId,
      kbSummaryVisible: true,
      sourceRowVisible: true,
      searchResultVisible: true,
      openReferenceControlsVisible: true,
      deletePreserveLocalFileControlVisible: true,
      screenshot: SCREENSHOT_PATH,
    };
    fs.writeFileSync(RESULT_PATH, `${JSON.stringify(result, null, 2)}\n`, "utf8");
    console.log(JSON.stringify(result, null, 2));
  } finally {
    await browser.close().catch(() => undefined);
  }
}

main().catch((error) => {
  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
  fs.writeFileSync(
    path.join(OUTPUT_DIR, "failure.json"),
    `${JSON.stringify({ ok: false, error: error.stack || error.message || String(error) }, null, 2)}\n`,
    "utf8",
  );
  console.error(error.stack || error.message || String(error));
  process.exit(1);
});