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

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

const ROOT = path.resolve(__dirname, "..");
const BASE_URL = (process.env.MNOTE_UI_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 OUT_DIR = path.join(ROOT, "tmp", "task441-local-folder-cloud-switch-smoke");

function fileUrl(filePath) {
  return `file://${filePath.split(path.sep).map((part, index) => (index === 0 ? "" : encodeURIComponent(part))).join("/")}`;
}

function cssString(value) {
  return String(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"');
}

async function quickLogin(page) {
  await page.goto(`${BASE_URL}/auth`, { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
  const quickLoginButton = page.getByRole("button", { name: "测试账号快速登录" });
  if (await quickLoginButton.count()) {
    await quickLoginButton.click({ timeout: UI_TIMEOUT_MS });
    await page.waitForURL((url) => url.pathname === "/", { timeout: UI_TIMEOUT_MS });
  }
}

async function openFileTree(page) {
  await page.evaluate(() => {
    const tab = document.querySelector('[data-mnote-sidebar-tree-tab="filetree"], button[aria-label="文件"]');
    if (tab instanceof HTMLElement) tab.click();
  });
  await page.locator("#sidebar-file-tree-root").waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
}

async function readCloudState(page) {
  return page.evaluate(() => {
    const workspaceNode = document.querySelector("#sidebar-file-tree-root[data-workspace-id], #sidebar-tree-root[data-workspace-id], [data-workspace-id]");
    const workspaceId = workspaceNode instanceof HTMLElement ? workspaceNode.getAttribute("data-workspace-id") || "" : "";
    const docRows = Array.from(document.querySelectorAll("#sidebar-file-tree-root .tree-row[data-row-id^='doc:']")).map((row) => ({
      rowId: row.getAttribute("data-row-id") || "",
      title: row.querySelector(".tree-link-title")?.textContent?.trim() || "",
    }));
    return {
      url: window.location.href,
      workspaceId,
      storageValue: window.localStorage.getItem("mnote.workspace.lastCloudWorkspaceId") || "",
      docRows,
      localRows: document.querySelectorAll("#sidebar-file-tree-root .tree-row[data-row-id^='local:']").length,
      rootText: document.querySelector("#sidebar-file-tree-root")?.textContent?.slice(0, 500) || "",
    };
  });
}

async function ensureCloudDocument(page) {
  await openFileTree(page);
  let state = await readCloudState(page);
  if (state.workspaceId && state.workspaceId !== "default" && state.docRows.length > 0) {
    return { workspaceId: state.workspaceId, rowId: state.docRows[0].rowId };
  }

  const previousPathname = new URL(page.url()).pathname;
  await page.getByRole("button", { name: "新建页面" }).click({ timeout: UI_TIMEOUT_MS });
  await page.waitForURL((url) => url.pathname.startsWith("/documents/") && url.pathname !== previousPathname, { timeout: UI_TIMEOUT_MS });
  const documentId = new URL(page.url()).pathname.split("/").filter(Boolean).pop();
  assert(documentId, "新建云空间页面后 URL 缺少 documentId");
  await openFileTree(page);
  await page.waitForFunction(
    (id) => Boolean(document.querySelector(`#sidebar-file-tree-root .tree-row[data-row-id="doc:${CSS.escape(id)}"]`)),
    documentId,
    { timeout: UI_TIMEOUT_MS },
  );
  state = await readCloudState(page);
  assert(state.workspaceId && state.workspaceId !== "default", `云空间 workspaceId 不应为空或 default: ${JSON.stringify(state)}`);
  return { workspaceId: state.workspaceId, rowId: `doc:${documentId}` };
}

async function openLocalFolder(page, root) {
  await page.locator('[data-testid="mnote-workspace-source-trigger"]').click({ timeout: UI_TIMEOUT_MS });
  await page.locator('[data-testid="mnote-workspace-source-menu"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
  await page.locator('[data-testid="mnote-open-other-local-folder"]').click({ timeout: UI_TIMEOUT_MS });
  await page.locator('[data-testid="mnote-local-folder-dialog"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
  await page.locator('[data-testid="mnote-local-folder-path-input"]').fill(root);
  await page.locator('[data-testid="mnote-local-folder-open-confirm"]').click({ timeout: UI_TIMEOUT_MS });
  await page.waitForURL(
    (url) => url.pathname === "/" && url.searchParams.get("sourceKind") === "local_folder" && url.searchParams.get("rootUri") === fileUrl(root),
    { timeout: UI_TIMEOUT_MS },
  );
  await page.locator("#sidebar-file-tree-root .tree-row[data-row-id='local:markdown:README.md']").waitFor({
    state: "visible",
    timeout: UI_TIMEOUT_MS,
  });
}

async function switchCloud(page) {
  await page.locator('[data-testid="mnote-workspace-source-trigger"]').click({ timeout: UI_TIMEOUT_MS });
  await page.locator('[data-testid="mnote-workspace-source-menu"]').waitFor({ state: "visible", timeout: UI_TIMEOUT_MS });
  await page.locator('[data-testid="mnote-switch-cloud-workspace"]').click({ timeout: UI_TIMEOUT_MS });
  await page.waitForURL(
    (url) => url.pathname === "/" && url.searchParams.get("sourceKind") === "convex_workspace" && !url.searchParams.has("rootUri"),
    { timeout: UI_TIMEOUT_MS },
  );
}

async function main() {
  await fsp.mkdir(OUT_DIR, { recursive: true });
  const localRoot = fs.mkdtempSync(path.join(os.tmpdir(), "mnote-cloud-switch-local-"));
  fs.writeFileSync(path.join(localRoot, "README.md"), "# Local README\n", "utf8");

  const browser = await chromium.launch({ headless: process.env.HEADFUL !== "1" });
  const context = await browser.newContext({ viewport: { width: 1440, height: 960 } });
  const page = await context.newPage();
  const result = { ok: false, baseUrl: BASE_URL, localRoot, cloudTarget: null, localState: null, returnedState: null };

  try {
    await quickLogin(page);
    await page.goto(BASE_URL, { waitUntil: "domcontentloaded", timeout: UI_TIMEOUT_MS });
    result.cloudTarget = await ensureCloudDocument(page);
    await openLocalFolder(page, localRoot);
    result.localState = await readCloudState(page);
    assert(result.localState.storageValue === result.cloudTarget.workspaceId, `进入本地文件夹前应记住真实云空间 workspaceId: ${JSON.stringify(result)}`);

    await switchCloud(page);
    await page.waitForURL((url) => url.searchParams.get("workspaceId") === result.cloudTarget.workspaceId, {
      timeout: UI_TIMEOUT_MS,
    });
    await openFileTree(page);
    await page.waitForFunction(
      (rowId) => Boolean(document.querySelector(`#sidebar-file-tree-root .tree-row[data-row-id="${CSS.escape(rowId)}"]`)),
      result.cloudTarget.rowId,
      { timeout: UI_TIMEOUT_MS },
    );
    result.returnedState = await readCloudState(page);

    assert.equal(result.returnedState.workspaceId, result.cloudTarget.workspaceId, "切回云空间后应恢复原 workspaceId");
    assert.equal(result.returnedState.storageValue, result.cloudTarget.workspaceId, "lastCloudWorkspaceId 不应被 default 污染");
    assert.notEqual(result.returnedState.storageValue, "default", "lastCloudWorkspaceId 不能是 synthetic default");
    assert.equal(result.returnedState.localRows, 0, "切回云空间后不应保留本地文件夹 row");
    assert(
      result.returnedState.docRows.some((row) => row.rowId === result.cloudTarget.rowId),
      `切回云空间后原云空间页面 row 应恢复: ${JSON.stringify(result.returnedState)}`,
    );

    result.ok = true;
  } finally {
    await fsp.writeFile(path.join(OUT_DIR, "result.json"), `${JSON.stringify(result, null, 2)}\n`, "utf8");
    await browser.close().catch(() => {});
    fs.rmSync(localRoot, { recursive: true, force: true });
  }

  console.log(JSON.stringify(result, null, 2));
}

main().catch((error) => {
  console.error(error);
  process.exit(1);
});