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

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

const TASK = "task786-openhub-history-refresh-browser-smoke";
const BASE_URL = (process.env.BASE_URL || process.env.MNOTE_UI_BASE_URL || "http://127.0.0.1:3000").replace(/\/+$/, "");
const UI_TIMEOUT_MS = Number(process.env.MNOTE_SMOKE_UI_TIMEOUT_MS || 30_000);
const STREAM_TIMEOUT_MS = Number(process.env.MNOTE_OPENHUB_STREAM_TIMEOUT_MS || 45_000);
const OUTPUT_DIR = path.join(process.cwd(), "tmp", "task786-openhub-history-refresh-browser-smoke");
const RESULT_PATH = path.join(OUTPUT_DIR, "result.json");
const FAILURE_PATH = path.join(OUTPUT_DIR, "failure.json");
const SCREENSHOT_PATH = path.join(OUTPUT_DIR, "openhub-history-refresh.png");
const TEST_EMAIL = "mnote.e2e@example.com";
const TEST_PASSWORD = "MnoteE2E123!";
const CHROMIUM_EXECUTABLE_PATH = process.env.PLAYWRIGHT_CHROMIUM_EXECUTABLE_PATH
  || ["/usr/bin/chromium-browser", "/usr/bin/chromium", "/usr/bin/google-chrome-stable", "/usr/bin/google-chrome", "/snap/bin/chromium"]
    .find((candidate) => fs.existsSync(candidate));

class SmokeFailure extends Error {
  constructor(layer, message, details = {}) {
    super(message);
    this.name = "SmokeFailure";
    this.layer = layer;
    this.details = details;
  }
}

function jsonSnippet(value, limit = 800) {
  if (typeof value === "string") return value.slice(0, limit);
  return JSON.stringify(value, null, 2).slice(0, limit);
}

function openHubProxyUrl(pathname, scopeQuery, extraParams = {}) {
  const url = new URL(`${BASE_URL}/page-ai/openhub/ai${pathname}`);
  const scopeParams = new URLSearchParams(String(scopeQuery || "").replace(/^\?/, ""));
  for (const [key, value] of scopeParams.entries()) {
    url.searchParams.set(key, value);
  }
  for (const [key, value] of Object.entries(extraParams)) {
    if (value !== undefined && value !== null) url.searchParams.set(key, String(value));
  }
  return url.toString();
}

async function parseJsonResponse(response, layer, label) {
  const text = await response.text();
  let payload = null;
  try {
    payload = text ? JSON.parse(text) : null;
  } catch {
    throw new SmokeFailure(layer, `${label} 返回非 JSON：HTTP ${response.status()}`, {
      status: response.status(),
      bodySnippet: text.slice(0, 800),
    });
  }
  if (!response.ok()) {
    throw new SmokeFailure(layer, `${label} 失败：HTTP ${response.status()}`, payload);
  }
  return payload;
}

async function assertMNoteReachable() {
  let response;
  try {
    response = await fetch(`${BASE_URL}/health`, { redirect: "manual", signal: AbortSignal.timeout(6_000) });
  } catch (error) {
    throw new SmokeFailure("mnote_service", `MNote 3000 服务不可达：${error.message}`, { baseUrl: BASE_URL });
  }
  if (!response.ok && response.status !== 303) {
    throw new SmokeFailure("mnote_service", `MNote /health 返回异常：HTTP ${response.status}`, { baseUrl: BASE_URL });
  }
}

async function signIn(requestContext) {
  const response = await requestContext.post(`${BASE_URL}/api/auth`, {
    data: {
      action: "auth:signIn",
      args: {
        provider: "password",
        params: {
          account: TEST_EMAIL,
          email: TEST_EMAIL,
          password: TEST_PASSWORD,
          flow: "signIn",
        },
      },
    },
    timeout: UI_TIMEOUT_MS,
  });
  const payload = await parseJsonResponse(response, "auth", "/api/auth 登录");
  const whoami = await requestContext.get(`${BASE_URL}/api/auth/whoami`, { timeout: UI_TIMEOUT_MS });
  const viewer = await parseJsonResponse(whoami, "auth", "/api/auth/whoami");
  if (!viewer || !viewer.userId) {
    throw new SmokeFailure("auth", "登录后 whoami 缺少 userId", { loginPayload: payload, whoami: viewer });
  }
  return viewer;
}

async function visibleAny(page, selectors, label) {
  await page.waitForFunction((candidateSelectors) => {
    const visible = (node) => {
      if (!(node instanceof HTMLElement)) return false;
      const style = window.getComputedStyle(node);
      const rect = node.getBoundingClientRect();
      return !node.hidden && style.display !== "none" && style.visibility !== "hidden" && rect.width > 0 && rect.height > 0;
    };
    return candidateSelectors.some((selector) => Array.from(document.querySelectorAll(selector)).some(visible));
  }, selectors, { timeout: UI_TIMEOUT_MS }).catch((error) => {
    throw new SmokeFailure("mnote_page_ai_ui", `${label} 不可见`, { selectors, cause: error.message });
  });
}

async function openMNoteOpenHubDrawer(page) {
  await page.goto(BASE_URL, { waitUntil: "commit", timeout: UI_TIMEOUT_MS });
  if (page.url().includes("/auth")) {
    throw new SmokeFailure("auth", "打开 MNote 主页后仍被重定向到 /auth", { url: page.url() });
  }

  await page.evaluate(() => {
    try {
      localStorage.setItem("mnote.page_ai.openhub_host", "1");
    } catch {}
  });

  await page.waitForFunction(() => (
    typeof window.__mnoteSidebarPageAiRuntime?.openPageAiDrawer === "function"
      || document.querySelector("[data-testid='wolai-floating-ai']")
      || document.querySelector("[data-testid='wolai-page-ai-drawer']")
  ), null, { timeout: UI_TIMEOUT_MS });

  const openedByRuntime = await page.evaluate(() => {
    try {
      localStorage.setItem("mnote.page_ai.openhub_host", "1");
      if (typeof window.__mnoteSidebarPageAiRuntime?.openPageAiDrawer === "function") {
        window.__mnoteSidebarPageAiRuntime.openPageAiDrawer();
        return true;
      }
    } catch {}
    return false;
  });

  if (!openedByRuntime) {
    const floating = page.locator("[data-testid='wolai-floating-ai']").first();
    if (await floating.isVisible({ timeout: 5_000 }).catch(() => false)) {
      await floating.click({ timeout: UI_TIMEOUT_MS });
    }
  }

  await visibleAny(page, ["[data-testid='wolai-page-ai-drawer']"], "Page AI drawer");
  await page.waitForFunction(() => {
    const drawer = document.querySelector("[data-testid='wolai-page-ai-drawer']");
    return drawer instanceof HTMLElement && drawer.getAttribute("data-page-ai-openhub-host") === "true";
  }, null, { timeout: UI_TIMEOUT_MS }).catch((error) => {
    throw new SmokeFailure("mnote_page_ai_ui", "Page AI drawer 未切到 OpenHub host", {
      cause: error.message,
      drawerText: "",
    });
  });

  await page.waitForFunction(() => {
    const iframe = document.querySelector("iframe[data-page-ai-openhub-iframe]");
    return iframe instanceof HTMLIFrameElement && (iframe.getAttribute("src") || "").includes("/page-ai/openhub/ai");
  }, null, { timeout: UI_TIMEOUT_MS }).catch((error) => {
    throw new SmokeFailure("mnote_page_ai_ui", "OpenHub iframe 未挂载或 src 未指向 /page-ai/openhub/ai", { cause: error.message });
  });
}

async function getOpenHubFrame(page) {
  const deadline = Date.now() + UI_TIMEOUT_MS;
  let lastState = null;
  while (Date.now() < deadline) {
    const handle = await page.locator("iframe[data-page-ai-openhub-iframe]").first().elementHandle().catch(() => null);
    if (handle) {
      const frame = await handle.contentFrame();
      lastState = {
        iframeSrc: await handle.getAttribute("src").catch(() => ""),
        frameUrl: frame ? frame.url() : "",
      };
      if (frame && frame.url().includes("/page-ai/openhub/ai")) {
        await frame.waitForLoadState("domcontentloaded", { timeout: 10_000 }).catch(() => undefined);
        return frame;
      }
    }
    await page.waitForTimeout(300);
  }
  throw new SmokeFailure("openhub_iframe_ui", "无法取得 OpenHub iframe frame", lastState || {});
}

async function collectFrameState(frame, marker) {
  return frame.evaluate((expectedMarker) => {
    const text = (selector) => (document.querySelector(selector)?.textContent || "").replace(/\s+/g, " ").trim();
    const bodyText = (document.body?.textContent || "").replace(/\s+/g, " ").trim();
    const drawerText = Array.from(document.querySelectorAll(".ant-drawer, [role='dialog']"))
      .map((node) => (node.textContent || "").replace(/\s+/g, " ").trim())
      .filter(Boolean)
      .join("\n");
    const messageAreaText = text(".messages-area");
    const historyButtons = Array.from(document.querySelectorAll("button"))
      .map((button) => (button.textContent || button.getAttribute("title") || button.getAttribute("aria-label") || "").replace(/\s+/g, " ").trim())
      .filter(Boolean);
    return {
      url: location.href,
      title: document.title,
      bodySnippet: bodyText.slice(0, 1200),
      iframeShellKind: document.body?.getAttribute("data-mnote-openhub-ai-shell") || "",
      hasReactRoot: Boolean(document.getElementById("root")),
      hasOpenHubTitle: bodyText.includes("OpenHub 平台"),
      hasHistoryButton: historyButtons.some((entry) => entry.includes("历史记录")),
      historyButtons,
      drawerTextSnippet: drawerText.slice(0, 1200),
      messageAreaSnippet: messageAreaText.slice(0, 1200),
      bodyHasMarker: bodyText.includes(expectedMarker),
      drawerHasMarker: drawerText.includes(expectedMarker),
      messageAreaHasMarker: messageAreaText.includes(expectedMarker),
      staticBoundaryVisible: /静态占位|static-boundary|最小 host\/bootstrap 占位/.test(bodyText),
      loginVisible: /(登录\s*OpenHub|OpenHub\s*Login|Sign in to OpenHub|WeKnora\s*登录)/i.test(bodyText),
    };
  }, marker);
}

function scopeQueryFromFrameUrl(frameUrl) {
  const url = new URL(frameUrl, BASE_URL);
  const query = url.searchParams.toString();
  if (!query || !url.searchParams.get("scope") || !url.searchParams.get("mnoteScope")) {
    throw new SmokeFailure("openhub_scope", "OpenHub iframe URL 缺少 scope/mnoteScope", { frameUrl });
  }
  return `?${query}`;
}

function parseStreamEvents(streamText) {
  const eventTypes = [];
  let returnedSessionId = "";
  let errorEvent = "";
  for (const line of String(streamText || "").split(/\r?\n/)) {
    if (!line.startsWith("data: ")) continue;
    try {
      const data = JSON.parse(line.slice(6));
      const payload = data.payload && data.payload.type
        ? { type: data.payload.type, ...data.payload.properties }
        : data;
      if (payload.type) eventTypes.push(payload.type);
      if (payload.conversation_id) returnedSessionId = payload.conversation_id;
      if (payload.error) errorEvent = String(payload.error);
    } catch {}
  }
  return {
    eventTypes: [...new Set(eventTypes)],
    returnedSessionId,
    errorEvent,
    snippet: String(streamText || "").slice(0, 1200),
  };
}

async function sendMarkerMessage(requestContext, scopeQuery, sessionId, marker) {
  const prompt = `${marker} Page AI OpenHub history refresh smoke. 请只回复 ${marker}，不要解释。`;
  const body = {
    question: prompt,
    conversation_id: sessionId,
    agent: "build",
  };
  const url = openHubProxyUrl("/api/query/stream", scopeQuery);
  try {
    const response = await requestContext.post(url, {
      data: body,
      headers: { "content-type": "application/json" },
      timeout: STREAM_TIMEOUT_MS,
    });
    const text = await response.text();
    return {
      ok: response.ok(),
      status: response.status(),
      prompt,
      ...parseStreamEvents(text),
    };
  } catch (error) {
    return {
      ok: false,
      status: 0,
      prompt,
      error: error instanceof Error ? error.message : String(error),
    };
  }
}

async function fetchMessagesUntilMarker(requestContext, scopeQuery, sessionId, marker) {
  let lastPayload = null;
  let lastStatus = 0;
  for (let attempt = 0; attempt < 12; attempt += 1) {
    const response = await requestContext.get(openHubProxyUrl(`/api/sessions/${encodeURIComponent(sessionId)}/messages`, scopeQuery), {
      timeout: UI_TIMEOUT_MS,
    });
    lastStatus = response.status();
    const payload = await response.json().catch(async () => ({ nonJson: await response.text().catch(() => "") }));
    lastPayload = payload;
    const messages = Array.isArray(payload?.data) ? payload.data : [];
    const userMessage = messages.find((message) => message.role === "user" && String(message.content || "").includes(marker));
    if (response.ok() && userMessage) {
      return {
        ok: true,
        status: response.status(),
        count: messages.length,
        roles: messages.map((message) => message.role),
        userMessageContent: String(userMessage.content || ""),
        lastMessages: messages.slice(-3).map((message) => ({
          role: message.role,
          content: String(message.content || "").slice(0, 300),
          created_at: message.created_at,
        })),
      };
    }
    await new Promise((resolve) => setTimeout(resolve, 1000));
  }
  throw new SmokeFailure("openhub_api_messages", "OpenHub API 未读回带 marker 的 user message", {
    sessionId,
    marker,
    status: lastStatus,
    payloadSnippet: jsonSnippet(lastPayload),
  });
}

async function fetchSessionsUntilMarker(requestContext, scopeQuery, sessionId, marker) {
  let lastPayload = null;
  for (let attempt = 0; attempt < 8; attempt += 1) {
    const response = await requestContext.get(openHubProxyUrl("/api/sessions", scopeQuery, { page: 1, page_size: 10 }), {
      timeout: UI_TIMEOUT_MS,
    });
    const payload = await response.json().catch(async () => ({ nonJson: await response.text().catch(() => "") }));
    lastPayload = payload;
    const sessions = Array.isArray(payload?.data) ? payload.data : [];
    const found = sessions.find((session) => String(session.session_id || session.id || "") === sessionId);
    const markerTitle = sessions.find((session) => String(session.title || "").includes(marker));
    if (response.ok() && (found || markerTitle)) {
      return {
        ok: true,
        status: response.status(),
        total: payload?.pagination?.total,
        foundSession: found || markerTitle,
        markerInTitle: Boolean(markerTitle),
        firstSessions: sessions.slice(0, 5).map((session) => ({
          session_id: session.session_id || session.id || "",
          title: session.title || "",
          updated_at: session.updated_at || "",
        })),
      };
    }
    await new Promise((resolve) => setTimeout(resolve, 1000));
  }
  throw new SmokeFailure("openhub_api_history", "OpenHub sessions API 未读回对应 session/history", {
    sessionId,
    marker,
    payloadSnippet: jsonSnippet(lastPayload),
  });
}

async function assertOpenHubReactUsable(frame, marker) {
  const state = await collectFrameState(frame, marker);
  if (state.staticBoundaryVisible) {
    throw new SmokeFailure("openhub_iframe_ui", "OpenHub iframe 仍是静态边界页，不能把 API-only 记为 UI 通过", state);
  }
  if (state.loginVisible) {
    throw new SmokeFailure("openhub_iframe_ui", "OpenHub iframe 出现独立登录入口", state);
  }
  if (!state.hasOpenHubTitle && !state.hasHistoryButton) {
    throw new SmokeFailure("openhub_iframe_ui", "OpenHub React AI 面板未渲染出历史入口", state);
  }
  return state;
}

async function openHistoryAndVerify(frame, sessionId, marker) {
  let beforeHistoryState = await collectFrameState(frame, marker);
  if (beforeHistoryState.messageAreaHasMarker) {
    return {
      uiMarkerVerified: true,
      historyMarkerVerified: false,
      currentMessageMarkerVerified: true,
      beforeHistoryState,
      afterHistoryState: beforeHistoryState,
      afterSessionClickState: beforeHistoryState,
    };
  }

  let historyButton = frame.getByRole("button", { name: /历史记录/ }).first();
  if (!(await historyButton.isVisible({ timeout: 3_000 }).catch(() => false))) {
    historyButton = frame.locator('button[title="历史记录"]').first();
  }
  if (!(await historyButton.isVisible({ timeout: 8_000 }).catch(() => false))) {
    throw new SmokeFailure("openhub_history_ui", "OpenHub iframe 内未找到历史记录按钮", beforeHistoryState);
  }
  await historyButton.click({ timeout: UI_TIMEOUT_MS });

  let afterHistoryState = null;
  for (let attempt = 0; attempt < 12; attempt += 1) {
    afterHistoryState = await collectFrameState(frame, marker);
    if (afterHistoryState.drawerHasMarker || afterHistoryState.bodyHasMarker) break;
    if (attempt === 2) {
      const refreshButton = frame.getByRole("button", { name: /刷新/ }).first();
      if (await refreshButton.isVisible({ timeout: 1_000 }).catch(() => false)) {
        await refreshButton.click({ timeout: UI_TIMEOUT_MS }).catch(() => undefined);
      }
    }
    await frame.waitForTimeout(1000);
  }

  const historyMarkerVerified = Boolean(afterHistoryState && (afterHistoryState.drawerHasMarker || afterHistoryState.bodyHasMarker));
  if (!historyMarkerVerified) {
    throw new SmokeFailure("openhub_history_ui", "刷新后 OpenHub history/session UI 未显示 marker/session 标题", {
      sessionId,
      marker,
      beforeHistoryState,
      afterHistoryState,
    });
  }

  const markerText = frame.getByText(marker, { exact: false }).first();
  if (await markerText.isVisible({ timeout: 5_000 }).catch(() => false)) {
    await markerText.click({ timeout: UI_TIMEOUT_MS }).catch(() => undefined);
  }

  let afterSessionClickState = null;
  for (let attempt = 0; attempt < 10; attempt += 1) {
    afterSessionClickState = await collectFrameState(frame, marker);
    if (afterSessionClickState.messageAreaHasMarker) break;
    await frame.waitForTimeout(1000);
  }

  return {
    uiMarkerVerified: historyMarkerVerified || Boolean(afterSessionClickState?.messageAreaHasMarker),
    historyMarkerVerified,
    currentMessageMarkerVerified: Boolean(afterSessionClickState?.messageAreaHasMarker),
    beforeHistoryState,
    afterHistoryState,
    afterSessionClickState,
  };
}

async function main() {
  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
  const suffix = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
  const marker = `TASK786_MARKER_${suffix}`;
  const sessionId = `task786-openhub-history-${suffix}`;
  let browser;
  let context;
  let page;
  let result = {
    ok: false,
    task: TASK,
    baseUrl: BASE_URL,
    sessionId,
    marker,
    screenshotPath: SCREENSHOT_PATH,
    uiMarker: "",
    historyMarker: "",
    uiMarkerVerified: false,
    historyMarkerVerified: false,
    currentMessageMarkerVerified: false,
  };

  try {
    await assertMNoteReachable();
    browser = await chromium.launch({
      headless: process.env.HEADFUL !== "1",
      ...(CHROMIUM_EXECUTABLE_PATH ? { executablePath: CHROMIUM_EXECUTABLE_PATH } : {}),
    });
    context = await browser.newContext({ viewport: { width: 1440, height: 960 }, locale: "zh-CN" });
    page = await context.newPage();

    const viewer = await signIn(context.request);
    await openMNoteOpenHubDrawer(page);
    let frame = await getOpenHubFrame(page);
    const initialFrameState = await assertOpenHubReactUsable(frame, marker);
    const scopeQuery = scopeQueryFromFrameUrl(frame.url());

    const sendStream = await sendMarkerMessage(context.request, scopeQuery, sessionId, marker);
    const apiMessages = await fetchMessagesUntilMarker(context.request, scopeQuery, sessionId, marker);
    const apiSessions = await fetchSessionsUntilMarker(context.request, scopeQuery, sessionId, marker);

    await page.reload({ waitUntil: "commit", timeout: UI_TIMEOUT_MS });
    await openMNoteOpenHubDrawer(page);
    frame = await getOpenHubFrame(page);
    const refreshedFrameState = await assertOpenHubReactUsable(frame, marker);
    const ui = await openHistoryAndVerify(frame, sessionId, marker);

    if (!ui.uiMarkerVerified) {
      throw new SmokeFailure("openhub_history_ui", "API 已读回 marker，但刷新后 UI 未恢复 marker/session", {
        sessionId,
        marker,
        ui,
      });
    }

    await page.screenshot({ path: SCREENSHOT_PATH, fullPage: true });
    result = {
      ...result,
      ok: true,
      viewer,
      scopeQueryKeys: Array.from(new URLSearchParams(scopeQuery.slice(1)).keys()),
      sendStream,
      apiMessageVerified: true,
      apiHistoryVerified: true,
      apiMessages,
      apiSessions,
      initialFrameState,
      refreshedFrameState,
      uiMarkerVerified: ui.uiMarkerVerified,
      historyMarkerVerified: ui.historyMarkerVerified,
      currentMessageMarkerVerified: ui.currentMessageMarkerVerified,
      uiMarker: ui.currentMessageMarkerVerified ? marker : "",
      historyMarker: ui.historyMarkerVerified ? marker : "",
      beforeHistoryState: ui.beforeHistoryState,
      afterHistoryState: ui.afterHistoryState,
      afterSessionClickState: ui.afterSessionClickState,
      resultPath: RESULT_PATH,
    };
    fs.writeFileSync(RESULT_PATH, `${JSON.stringify(result, null, 2)}\n`, "utf8");
    if (fs.existsSync(FAILURE_PATH)) fs.rmSync(FAILURE_PATH, { force: true });
  } catch (error) {
    if (page) {
      await page.screenshot({ path: SCREENSHOT_PATH, fullPage: true }).catch(() => undefined);
    }
    result = {
      ...result,
      ok: false,
      failureLayer: error instanceof SmokeFailure ? error.layer : "unexpected",
      error: error instanceof Error ? error.stack || error.message : String(error),
      details: error instanceof SmokeFailure ? error.details : undefined,
      failurePath: FAILURE_PATH,
    };
    fs.writeFileSync(FAILURE_PATH, `${JSON.stringify(result, null, 2)}\n`, "utf8");
    if (fs.existsSync(RESULT_PATH)) fs.rmSync(RESULT_PATH, { force: true });
  } finally {
    if (context) await context.close().catch(() => undefined);
    if (browser) await browser.close().catch(() => undefined);
  }

  console.log(JSON.stringify(result, null, 2));
  if (!result.ok) process.exit(1);
}

main().catch((error) => {
  const failure = {
    ok: false,
    task: TASK,
    baseUrl: BASE_URL,
    failureLayer: "fatal",
    error: error instanceof Error ? error.stack || error.message : String(error),
    failurePath: FAILURE_PATH,
  };
  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
  fs.writeFileSync(FAILURE_PATH, `${JSON.stringify(failure, null, 2)}\n`, "utf8");
  console.error(JSON.stringify(failure, null, 2));
  process.exit(1);
});