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

const { loginViaAuthForm } = require('./lib/browser-auth-login');
/**
 * task474-local-folder-empty-trash-ui-smoke.js
 *
 * 用途：验证 local folder trash workbench 的清空垃圾箱 UI 流程：
 *   1. 清空页面垃圾箱（empty documents）
 *   2. 清空资源垃圾箱（empty resources）
 *   断言：行消失、trash-index.json 清理、trash 文件删除、无页面导航
 *
 * 不修改 Rust / SSR 代码。只验证现有行为、记录证据。
 *
 * Usage:
 *   node scripts/task474-local-folder-empty-trash-ui-smoke.js
 *
 * Env:
 *   MNOTE_WEB_SMOKE_BASE_URL    — 3000 地址，默认 http://127.0.0.1:3000
 *   MNOTE_SMOKE_UI_TIMEOUT_MS   — UI 等待超时，默认 30_000
 *   MNOTE_KEEP_SMOKE_TMP        — 设置后保留临时目录
 */

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

const TASK = "task474-local-folder-empty-trash-ui-smoke";
const BASE_URL = (process.env.MNOTE_WEB_SMOKE_BASE_URL || "http://127.0.0.1:3000").replace(/\/+$/, "");
const UI_TIMEOUT_MS = Number(process.env.MNOTE_SMOKE_UI_TIMEOUT_MS || 30_000);
const OUTPUT_DIR = path.join(process.cwd(), "tmp", TASK);
const RESULT_PATH = path.join(OUTPUT_DIR, "result.json");
const CHROMIUM_EXECUTABLE_PATH = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH
  || ["/usr/bin/google-chrome-stable", "/usr/bin/google-chrome", "/snap/bin/chromium", "/usr/bin/chromium"]
    .find((candidate) => fs.existsSync(candidate));

function fileUrl(localPath) {
  return `file://${localPath}`;
}

function writeWorkspaceManifest(root) {
  const metadataDir = path.join(root, ".mnote");
  fs.mkdirSync(metadataDir, { recursive: true });
  fs.writeFileSync(
    path.join(metadataDir, "workspace.json"),
    `${JSON.stringify({
      workspaceId: `local-ws:user_real:${TASK}`,
      ownerId: "user_real",
      createdAt: new Date().toISOString(),
      capabilities: ["local_files", "tree_commands", "markdown_edit", "asset_upload"],
    }, null, 2)}\n`,
    "utf8",
  );
}

/**
 * 编码本地路径段，匹配 Rust encode_local_id_segment 逻辑
 */
function encodeLocalIdSegment(value) {
  let encoded = "";
  for (let i = 0; i < value.length; i++) {
    const ch = value[i];
    const code = value.charCodeAt(i);
    if ((code >= 0x30 && code <= 0x39) || (code >= 0x41 && code <= 0x5A) || (code >= 0x61 && code <= 0x7A) || ch === "." || ch === "_" || ch === "-") {
      encoded += ch;
    } else {
      encoded += "~" + code.toString(16).toUpperCase().padStart(2, "0");
    }
  }
  return encoded;
}

/**
 * Tree command 快捷请求
 */
async function postTreeCommand(rootUri, action, documentId) {
  const response = await fetch(`${BASE_URL}/api/tree/commands`, {
    method: "POST",
    headers: {
      "content-type": "application/json",
      "x-mnote-actor-id": "user_real",
      "x-mnote-actor-type": "user",
    },
    body: JSON.stringify({
      action,
      sourceKind: "local_folder",
      rootUri,
      documentId,
    }),
  });
  const payload = await response.json().catch(async () => ({ text: await response.text() }));
  assert.equal(response.status, 200, `${action} failed: ${JSON.stringify(payload)}`);
  return payload;
}

/**
 * 快速登录（测试账号）
 */
async function quickLogin(page) {
  // 7-76 P0: 标准表单登录（无测试快速登录按钮）
  const base =
    (typeof BASE_URL !== "undefined" && BASE_URL) ||
    (typeof baseUrl !== "undefined" && baseUrl) ||
    process.env.MNOTE_UI_BASE_URL ||
    "http://127.0.0.1:3000";
  const timeout =
    (typeof UI_TIMEOUT_MS !== "undefined" && UI_TIMEOUT_MS) ||
    (typeof TIMEOUT !== "undefined" && TIMEOUT) ||
    30_000;
  if (!String(page.url() || "").includes("/auth")) {
    await page.goto(String(base).replace(/\/+$/, "") + "/auth", {
      waitUntil: "commit",
      timeout,
    });
  }
  await loginViaAuthForm(page, {
    baseUrl: base,
    timeoutMs: timeout,
    gotoAuth: false,
  });
  await page
    .waitForURL((url) => !String(url).includes("/auth"), { timeout })
    .catch(() => {});
}

/**
 * 构建 trash 页 URL
 */
function trashUrl(rootUri) {
  const url = new URL(`${BASE_URL}/trash`);
  url.searchParams.set("sourceKind", "local_folder");
  url.searchParams.set("rootUri", rootUri);
  return url.toString();
}

/**
 * 打开 trash 页并等待 workbench 可见
 */
async function openTrash(page, rootUri) {
  await page.goto(trashUrl(rootUri), { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
  await page.locator('[data-testid="mnote-trash-workbench"][data-trash-source-kind="local_folder"]').waitFor({
    state: "visible",
    timeout: UI_TIMEOUT_MS,
  });
}

/**
 * 读取 trash-index.json 的 entries map
 */
function readTrashIndex(root) {
  const indexPath = path.join(root, ".mnote", "trash-index.json");
  if (!fs.existsSync(indexPath)) return {};
  const raw = fs.readFileSync(indexPath, "utf8");
  const data = JSON.parse(raw);
  return data.entries || data || {};
}

/**
 * 读取 trash-index.json 中指定 entry
 */
function getTrashEntry(root, entryId) {
  const entries = readTrashIndex(root);
  return entries[entryId] || null;
}

/**
 * 从 trash-index.json 获取 entry 的 trashPath
 */
function getTrashFilePath(root, entryId) {
  const entry = getTrashEntry(root, entryId);
  if (!entry) return null;
  return entry.trashRelativePath || entry.trash_relative_path || entry.trashFilePath || entry.trashed_file_path || null;
}

async function main() {
  const root = fs.mkdtempSync(path.join(os.tmpdir(), `mnote-${TASK}-`));
  const rootUri = fileUrl(root);

  // ── 测试数据：两个松散 Markdown 页面和非 md 资源 ──
  const mdRelativePath = "docs/test-page.md";
  const mdDocId = `local-md:${encodeLocalIdSegment(mdRelativePath)}`; // local-md:docs~2Ftest-page.md
  const mdSourcePath = path.join(root, mdRelativePath);

  const md2RelativePath = "docs/second-page.md";
  const md2DocId = `local-md:${encodeLocalIdSegment(md2RelativePath)}`; // local-md:docs~2Fsecond-page.md
  const md2SourcePath = path.join(root, md2RelativePath);

  const assetRelativePath = "docs/resource.txt";
  const assetId = `local-file:${assetRelativePath}`; // local-file:docs/resource.txt
  const assetSourcePath = path.join(root, assetRelativePath);

  // 准备 workspace
  fs.mkdirSync(path.join(root, "docs"), { recursive: true });
  writeWorkspaceManifest(root);
  fs.writeFileSync(path.join(root, "README.md"), "# Local Root\n", "utf8");
  fs.writeFileSync(mdSourcePath, "# Test Page\n\nPage content for empty-trash smoke.\n", "utf8");
  fs.writeFileSync(md2SourcePath, "# Second Page\n\nSecond page content for multi-purge smoke.\n", "utf8");
  fs.writeFileSync(assetSourcePath, "resource body for empty-trash smoke\n", "utf8");

  const browser = await chromium.launch({
    headless: true,
    ...(CHROMIUM_EXECUTABLE_PATH ? { executablePath: CHROMIUM_EXECUTABLE_PATH } : {}),
  });
  const context = await browser.newContext({
    viewport: { width: 1360, height: 900 },
    extraHTTPHeaders: {
      "x-mnote-actor-id": "user_real",
      "x-mnote-actor-type": "user",
    },
  });
  const page = await context.newPage();

  // 导航事件记录
  const navigationEvents = [];
  page.on("framenavigated", (frame) => {
    if (frame === page.mainFrame()) {
      navigationEvents.push({ url: frame.url(), timestamp: Date.now() });
    }
  });

  const evidence = {
    ok: false,
    task: TASK,
    baseUrl: BASE_URL,
    root,
    mdRelativePath,
    mdDocId,
    md2RelativePath,
    md2DocId,
    assetRelativePath,
    assetId,
    steps: [],
    emptyDocuments: {},
    emptyResources: {},
    navEvents: [],
  };

  try {
    // ════════════════════════════════════════════
    // 步骤 1：登录并归档两个条目到垃圾箱
    // ════════════════════════════════════════════
    await quickLogin(page);

    // 归档 Markdown 页面
    const mdArchiveResult = await postTreeCommand(rootUri, "delete", mdDocId);
    assert.equal(mdArchiveResult.result?.execution?.resourceKind, "markdown",
      `MD archive resourceKind should be markdown, got: ${JSON.stringify(mdArchiveResult)}`);
    assert.equal(fs.existsSync(mdSourcePath), false, "archive 后源 Markdown 文件应移入垃圾箱");
    const mdTrashPath = mdArchiveResult.result?.execution?.trashPath
      || mdArchiveResult.trashPath
      || getTrashFilePath(root, mdDocId);
    assert.ok(mdTrashPath, `MD archive 应返回 trashPath, got: ${JSON.stringify(mdArchiveResult)}`);

    // 归档第二个 Markdown 页面，覆盖清空页面垃圾箱多条目串行 purge
    const md2ArchiveResult = await postTreeCommand(rootUri, "delete", md2DocId);
    assert.equal(md2ArchiveResult.result?.execution?.resourceKind, "markdown",
      `MD2 archive resourceKind should be markdown, got: ${JSON.stringify(md2ArchiveResult)}`);
    assert.equal(fs.existsSync(md2SourcePath), false, "archive 后第二个 Markdown 源文件应移入垃圾箱");
    const md2TrashPath = md2ArchiveResult.result?.execution?.trashPath
      || md2ArchiveResult.trashPath
      || getTrashFilePath(root, md2DocId);
    assert.ok(md2TrashPath, `MD2 archive 应返回 trashPath, got: ${JSON.stringify(md2ArchiveResult)}`);

    // 归档非 md 资源
    const assetArchiveResult = await postTreeCommand(rootUri, "delete", assetId);
    assert.equal(assetArchiveResult.result?.execution?.canonicalCommand, "tree.resource.archive",
      `Asset archive should be tree.resource.archive, got: ${JSON.stringify(assetArchiveResult)}`);
    assert.equal(fs.existsSync(assetSourcePath), false, "archive 后源文件应移入垃圾箱");
    const assetTrashPath = assetArchiveResult.result?.execution?.trashPath
      || assetArchiveResult.trashPath
      || getTrashFilePath(root, assetId);
    assert.ok(assetTrashPath, `Asset archive 应返回 trashPath, got: ${JSON.stringify(assetArchiveResult)}`);

    evidence.steps.push({
      step: 1,
      label: "通过 tree command 归档 Markdown 页面和非 md 资源到垃圾箱",
      ok: true,
      mdTrashPath,
      md2TrashPath,
      assetTrashPath,
    });

    // 验证 trash-index.json 包含三个 entry
    const entriesBefore = readTrashIndex(root);
    assert.ok(entriesBefore[mdDocId], `trash-index 应包含 MD entry: ${mdDocId}`);
    assert.ok(entriesBefore[md2DocId], `trash-index 应包含第二个 MD entry: ${md2DocId}`);
    assert.ok(entriesBefore[assetId], `trash-index 应包含 asset entry: ${assetId}`);

    // ════════════════════════════════════════════
    // 步骤 2：打开 trash 页，验证两行可见
    // ════════════════════════════════════════════
    const navBeforeTrashOpen = navigationEvents.length;
    await openTrash(page, rootUri);
    const trashOpenNavDelta = navigationEvents.length - navBeforeTrashOpen;

    // MD 行（页面垃圾箱）
    const mdTrashRow = page.locator(`article[data-trash-row="local"][data-trash-entry-id="${mdDocId}"]`);
    await mdTrashRow.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    const mdResourceKind = await mdTrashRow.getAttribute("data-resource-kind");
    assert.equal(mdResourceKind, "markdown", `MD trash row data-resource-kind 应为 "markdown", 实际: ${mdResourceKind}`);

    const md2TrashRow = page.locator(`article[data-trash-row="local"][data-trash-entry-id="${md2DocId}"]`);
    await md2TrashRow.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    const md2ResourceKind = await md2TrashRow.getAttribute("data-resource-kind");
    assert.equal(md2ResourceKind, "markdown", `第二个 MD trash row data-resource-kind 应为 "markdown", 实际: ${md2ResourceKind}`);

    // Asset 行（资源垃圾箱）
    const assetTrashRow = page.locator(`article[data-trash-row="local"][data-trash-entry-id="${assetId}"]`);
    await assetTrashRow.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    const assetResourceKind = await assetTrashRow.getAttribute("data-resource-kind");
    assert.equal(assetResourceKind, "local_file", `Asset trash row data-resource-kind 应为 "local_file", 实际: ${assetResourceKind}`);

    // 验证按钮 enabled 状态
    const emptyDocsButton = page.locator('[data-trash-action="local-empty-documents"]');
    const emptyResourcesButton = page.locator('[data-trash-action="local-empty-resources"]');
    await emptyDocsButton.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    await emptyResourcesButton.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    const docsButtonDisabled = await emptyDocsButton.isDisabled();
    const resourcesButtonDisabled = await emptyResourcesButton.isDisabled();
    assert.equal(docsButtonDisabled, false, "存在页面时清空页面垃圾箱按钮应 enabled");
    assert.equal(resourcesButtonDisabled, false, "存在资源时清空资源垃圾箱按钮应 enabled");

    evidence.steps.push({
      step: 2,
      label: "打开 trash 页，两行可见，按钮 enabled",
      ok: true,
      trashOpenNavDelta,
    });

    // ════════════════════════════════════════════
    // 步骤 3：清空页面垃圾箱
    // ════════════════════════════════════════════
    const navBeforeEmptyDocs = navigationEvents.length;

    // 确认 dialog：清空后无法恢复，确定继续吗？
    page.once("dialog", (dialog) => {
      evidence.emptyDocuments.dialogText = dialog.message();
      dialog.accept();
    });
    await emptyDocsButton.click({ timeout: UI_TIMEOUT_MS });

    // 等待 document rows 消失（refresh() 替换 innerHTML 后文档行应被移除）
    // 由于 refresh() 以 fetch+DOMParser 方式替换 innerHTML，原来 DOM 引用会变为 detached
    await page.waitForFunction(
      (id) => !document.querySelector(`[data-trash-entry-id="${id}"]`),
      mdDocId,
      { timeout: UI_TIMEOUT_MS },
    );
    await page.waitForFunction(
      (id) => !document.querySelector(`[data-trash-entry-id="${id}"]`),
      md2DocId,
      { timeout: UI_TIMEOUT_MS },
    );

    // 现在重新获取 DOM 引用验证
    const mdRowAfterEmptyDocs = page.locator(`article[data-trash-row="local"][data-trash-entry-id="${mdDocId}"]`);
    const mdRowCountAfterEmptyDocs = await mdRowAfterEmptyDocs.count();
    assert.equal(mdRowCountAfterEmptyDocs, 0, "清空页面垃圾箱后 MD 行应消失");
    const md2RowAfterEmptyDocs = page.locator(`article[data-trash-row="local"][data-trash-entry-id="${md2DocId}"]`);
    const md2RowCountAfterEmptyDocs = await md2RowAfterEmptyDocs.count();
    assert.equal(md2RowCountAfterEmptyDocs, 0, "清空页面垃圾箱后第二个 MD 行应消失");

    // 文档行消失后，资源行应仍然存在
    const assetRowAfterEmptyDocs = page.locator(`article[data-trash-row="local"][data-trash-entry-id="${assetId}"]`);
    const assetRowCountAfterEmptyDocs = await assetRowAfterEmptyDocs.count();
    assert.equal(assetRowCountAfterEmptyDocs, 1, "清空页面垃圾箱后资源行应仍然存在");

    // 验证按钮状态：文档按钮 disabled，资源按钮仍 enabled
    const docsButtonDisabledAfter = await page.locator('[data-trash-action="local-empty-documents"]').isDisabled();
    assert.equal(docsButtonDisabledAfter, true, "清空页面垃圾箱后 empty-documents 按钮应 disabled");

    // 验证文件系统：trash 文件和 trash-index
    const mdEntryAfterEmptyDocs = getTrashEntry(root, mdDocId);
    assert.equal(mdEntryAfterEmptyDocs, null, `清空页面垃圾箱后 trash-index 不应包含 MD entry: ${mdDocId}`);
    const md2EntryAfterEmptyDocs = getTrashEntry(root, md2DocId);
    assert.equal(md2EntryAfterEmptyDocs, null, `清空页面垃圾箱后 trash-index 不应包含第二个 MD entry: ${md2DocId}`);

    const resolvedMdTrashPath = path.resolve(root, mdTrashPath);
    assert.equal(fs.existsSync(resolvedMdTrashPath), false, `清空页面垃圾箱后 trash 文件应删除: ${resolvedMdTrashPath}`);
    const resolvedMd2TrashPath = path.resolve(root, md2TrashPath);
    assert.equal(fs.existsSync(resolvedMd2TrashPath), false, `清空页面垃圾箱后第二个 trash 文件应删除: ${resolvedMd2TrashPath}`);

    // 导航断言：清空操作不应触发页面导航
    const navAfterEmptyDocs = navigationEvents.length;
    const emptyDocsNavDelta = navAfterEmptyDocs - navBeforeEmptyDocs;
    assert.equal(emptyDocsNavDelta, 0,
      `清空页面垃圾箱后应无页面导航，实际发生 ${emptyDocsNavDelta} 次`);

    evidence.emptyDocuments = {
      ok: true,
      navDelta: emptyDocsNavDelta,
      dialogAccepted: true,
      mdEntryClean: mdEntryAfterEmptyDocs === null,
      md2EntryClean: md2EntryAfterEmptyDocs === null,
      mdFileGone: !fs.existsSync(resolvedMdTrashPath),
      md2FileGone: !fs.existsSync(resolvedMd2TrashPath),
    };
    evidence.steps.push({
      step: 3,
      label: "清空页面垃圾箱——按钮 click、accept confirm、行消失、trash-index 清理、文件删除、无导航",
      ok: true,
      navDelta: emptyDocsNavDelta,
    });

    // ════════════════════════════════════════════
    // 步骤 4：清空资源垃圾箱
    // ════════════════════════════════════════════
    const navBeforeEmptyResources = navigationEvents.length;

    const resourceButtonAfterEmptyDocs = page.locator('[data-trash-action="local-empty-resources"]');
    await resourceButtonAfterEmptyDocs.waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
    const resButtonDisabledAfterDocs = await resourceButtonAfterEmptyDocs.isDisabled();
    assert.equal(resButtonDisabledAfterDocs, false, "资源行仍存在时 empty-resources 按钮应 enabled");

    // 接受确认 dialog
    page.once("dialog", (dialog) => {
      evidence.emptyResources.dialogText = dialog.message();
      dialog.accept();
    });
    await resourceButtonAfterEmptyDocs.click({ timeout: UI_TIMEOUT_MS });

    // 等待资源行消失
    await page.waitForFunction(
      (id) => !document.querySelector(`[data-trash-entry-id="${id}"]`),
      assetId,
      { timeout: UI_TIMEOUT_MS },
    );

    const assetRowAfterEmptyResources = page.locator(`article[data-trash-row="local"][data-trash-entry-id="${assetId}"]`);
    const assetRowCountAfterEmptyResources = await assetRowAfterEmptyResources.count();
    assert.equal(assetRowCountAfterEmptyResources, 0, "清空资源垃圾箱后资源行应消失");

    // 验证按钮状态
    const resButtonDisabledAfter = await page.locator('[data-trash-action="local-empty-resources"]').isDisabled();
    assert.equal(resButtonDisabledAfter, true, "清空资源垃圾箱后 empty-resources 按钮应 disabled");

    // 验证文件系统
    const assetEntryAfterEmptyResources = getTrashEntry(root, assetId);
    assert.equal(assetEntryAfterEmptyResources, null, `清空资源垃圾箱后 trash-index 不应包含 asset entry: ${assetId}`);

    const resolvedAssetTrashPath = path.resolve(root, assetTrashPath);
    assert.equal(fs.existsSync(resolvedAssetTrashPath), false, `清空资源垃圾箱后 trash 文件应删除: ${resolvedAssetTrashPath}`);

    // 导航断言
    const navAfterEmptyResources = navigationEvents.length;
    const emptyResourcesNavDelta = navAfterEmptyResources - navBeforeEmptyResources;
    assert.equal(emptyResourcesNavDelta, 0,
      `清空资源垃圾箱后应无页面导航，实际发生 ${emptyResourcesNavDelta} 次`);

    evidence.emptyResources = {
      ok: true,
      navDelta: emptyResourcesNavDelta,
      dialogAccepted: true,
      assetEntryClean: assetEntryAfterEmptyResources === null,
      assetFileGone: !fs.existsSync(resolvedAssetTrashPath),
    };
    evidence.steps.push({
      step: 4,
      label: "清空资源垃圾箱——按钮 click、accept confirm、行消失、trash-index 清理、文件删除、无导航",
      ok: true,
      navDelta: emptyResourcesNavDelta,
    });

    // ════════════════════════════════════════════
    // 步骤 5：最终验证——trash-index.json 完全空
    // ════════════════════════════════════════════
    const entriesAfter = readTrashIndex(root);
    const entryKeys = Object.keys(entriesAfter);
    assert.equal(entryKeys.length, 0, `两次清空后 trash-index 应为空，实际有 ${entryKeys.length} 个 entry: ${JSON.stringify(entryKeys)}`);

    // 验证原始源文件不应恢复
    assert.equal(fs.existsSync(mdSourcePath), false, "清空垃圾箱后 MD 源文件不应恢复");
    assert.equal(fs.existsSync(md2SourcePath), false, "清空垃圾箱后第二个 MD 源文件不应恢复");
    assert.equal(fs.existsSync(assetSourcePath), false, "清空垃圾箱后资源源文件不应恢复");

    evidence.steps.push({
      step: 5,
      label: "最终验证：trash-index 为空、源文件未恢复",
      ok: true,
      entryKeys,
    });

    // 收集完整导航事件
    evidence.navEvents = navigationEvents.map((e) => ({
      url: e.url.length > 120 ? e.url.substring(0, 120) + "…" : e.url,
      timestamp: e.timestamp,
    }));
    evidence.ok = true;

    console.log(JSON.stringify({ ok: true, resultPath: RESULT_PATH, steps: evidence.steps.length }, null, 2));
  } catch (error) {
    evidence.error = error instanceof Error ? error.stack || error.message : String(error);
    evidence.pageUrl = page.url();
    evidence.pageText = await page.locator('[data-testid="mnote-trash-workbench"]').innerText({ timeout: 3000 }).catch(() => "");
    throw error;
  } finally {
    // 写结果文件
    fs.mkdirSync(OUTPUT_DIR, { recursive: true });
    fs.writeFileSync(RESULT_PATH, `${JSON.stringify(evidence, null, 2)}\n`, "utf8");
    console.log(JSON.stringify({ ok: evidence.ok, resultPath: RESULT_PATH, error: evidence.error || null }, null, 2));

    await context.close().catch(() => undefined);
    await browser.close().catch(() => undefined);
    if (!process.env.MNOTE_KEEP_SMOKE_TMP) {
      fs.rmSync(root, { recursive: true, force: true });
    }
  }
}

main().catch((error) => {
  console.error(error && error.stack ? error.stack : error);
  process.exit(1);
});