import { readFileSync } from "node:fs";
import { appendFile } from "node:fs/promises";
import { expect, type Page } from "@playwright/test";
import { openSettings } from "./app";
import { getE2EDaemonPort } from "./daemon-port";
import { escapeRegex } from "./regex";
import { openSettingsHost, openSettingsHostSection, openSettingsSection } from "./settings";

interface DaemonApiStatus {
  version: string;
  serverId: string;
  hostname: string;
}

interface PidFileContent {
  pid: number;
  desktopManaged: boolean;
}

export interface RealDaemonState {
  version: string;
  pid: number | null;
  logPath: string;
}

/**
 * Reads live state from the running E2E test daemon: version from the HTTP
 * status endpoint, PID from the paseo.pid lock file, log path from the
 * E2E_PASEO_HOME directory. Call this in Node test code (not in the browser).
 */
export async function loadRealDaemonState(): Promise<RealDaemonState> {
  const port = getE2EDaemonPort();
  const paseoHome = process.env.E2E_PASEO_HOME;
  if (!paseoHome) throw new Error("E2E_PASEO_HOME not set — globalSetup must run first");

  const resp = await fetch(`http://127.0.0.1:${port}/api/status`);
  const data: DaemonApiStatus = await resp.json();

  let pid: number | null = null;
  try {
    const raw = readFileSync(`${paseoHome}/paseo.pid`, "utf8");
    const pidContent: PidFileContent = JSON.parse(raw);
    pid = pidContent.pid ?? null;
  } catch (err) {
    // PID file may not be present yet on a very fresh daemon start
    console.warn("[desktop-updates] paseo.pid not found:", err);
  }

  return { version: data.version, pid, logPath: `${paseoHome}/daemon.log` };
}

export interface DesktopBridgeConfig {
  serverId: string;
  updateAvailable?: boolean;
  latestVersion?: string;
  updateReadyToInstall?: boolean;
  slowInstall?: boolean;
  /** Initial PID reported by desktop_daemon_status. Defaults to null. */
  daemonPid?: number | null;
  daemonVersion?: string | null;
  daemonLogPath?: string;
  /** Initial manageBuiltInDaemon setting. Defaults to false. */
  manageBuiltInDaemon?: boolean;
  /** Daemon listen address reported by desktop_daemon_status. Defaults to 127.0.0.1:6767. */
  daemonListen?: string;
  /** Keep start_desktop_daemon pending to hold the desktop startup blocker open. */
  hangDaemonStart?: boolean;
  /** Delay the desktop settings IPC response to exercise startup ordering. */
  desktopSettingsDelayMs?: number;
  /**
   * Controls what dialog.ask returns when the daemon management confirm dialog
   * fires. True = confirm (proceed with the action), false = cancel. Defaults to
   * false so tests that only assert copy don't inadvertently trigger state changes.
   */
  confirmShouldAccept?: boolean;
  dialogOpenResult?: string | string[] | null;
  editorTargets?: DesktopEditorTargetConfig[];
  editorRecordPath?: string;
}

interface DesktopEditorTargetConfig {
  id: string;
  label: string;
  kind: "editor" | "file-manager";
  icon: { kind: "image"; dataUrl: string } | { kind: "symbol"; name: "folder" | "terminal" };
}

interface DesktopEditorOpenRecord {
  editorId: string;
  workspacePath: string;
  filePath?: string;
  line?: number;
  column?: number;
}

export interface ConfirmDialogCall {
  message: string;
  title: string | undefined;
}

declare global {
  interface Window {
    __capturedDialogCall: ConfirmDialogCall | undefined;
    __capturedDialogOpenCalls: Array<Record<string, unknown> | undefined>;
    __recordDesktopEditorOpen?: (input: DesktopEditorOpenRecord) => Promise<void>;
    __desktopDaemonStartRequested?: boolean;
  }
}

/**
 * Injects window.paseoDesktop before app load so all Electron-gated code
 * activates. The update-check IPC is mocked at the boundary so the real
 * auto-updater never fires. Daemon start/stop commands are stateful: the mock
 * tracks running state and assigns a fresh PID on each start, letting tests
 * observe PID changes without touching the real E2E daemon process.
 * dialog.ask captures call arguments on window.__capturedDialogCall so tests
 * can assert dialog copy without depending on window.confirm concatenation.
 */
export async function injectDesktopBridge(page: Page, config: DesktopBridgeConfig): Promise<void> {
  if (config.editorRecordPath) {
    await page.exposeFunction(
      "__recordDesktopEditorOpen",
      async (input: DesktopEditorOpenRecord) => {
        await appendFile(config.editorRecordPath as string, `${JSON.stringify(input)}\n`, "utf8");
      },
    );
  }

  await page.addInitScript((cfg) => {
    // Mutable state shared across IPC calls within this page
    let manageDaemon = cfg.manageBuiltInDaemon ?? false;
    let daemonRunning = true;
    let currentPid: number | null = cfg.daemonPid ?? null;
    let startCount = 0;
    window.__desktopDaemonStartRequested = false;

    function buildDaemonStatus() {
      return {
        serverId: cfg.serverId,
        status: daemonRunning ? "running" : "stopped",
        listen: cfg.daemonListen ?? "127.0.0.1:6767",
        hostname: null,
        pid: currentPid,
        home: "",
        version: cfg.daemonVersion ?? null,
        desktopManaged: manageDaemon,
        error: null,
      };
    }

    function startDesktopDaemon() {
      window.__desktopDaemonStartRequested = true;
      if (cfg.hangDaemonStart) {
        return new Promise(() => undefined);
      }
      startCount += 1;
      daemonRunning = true;
      // First start (bootstrap) returns the configured PID; subsequent starts
      // (after a stop) get a fresh PID so tests can observe the change.
      currentPid = (cfg.daemonPid ?? 10000) + (startCount - 1) * 1000;
      return buildDaemonStatus();
    }

    async function waitForDesktopSettingsResponse() {
      const delayMs = cfg.desktopSettingsDelayMs ?? 0;
      if (delayMs > 0) {
        await new Promise<void>((resolve) => setTimeout(resolve, delayMs));
      }
    }

    const desktopBridge: {
      platform: string;
      invoke: (command: string, args?: Record<string, unknown>) => Promise<unknown>;
      dialog: {
        ask: (message: string, options?: Record<string, unknown>) => Promise<boolean>;
        open: (options?: Record<string, unknown>) => Promise<string | string[] | null>;
      };
      getPendingOpenProject: () => Promise<string | null>;
      events: { on: () => Promise<() => void> };
      editor?: {
        listTargets: () => Promise<DesktopEditorTargetConfig[]>;
        openTarget: (input: DesktopEditorOpenRecord) => Promise<void>;
      };
    } = {
      platform: "darwin",
      invoke: async (command: string, args?: Record<string, unknown>) => {
        if (command === "check_app_update") {
          return cfg.updateAvailable
            ? {
                hasUpdate: true,
                readyToInstall: cfg.updateReadyToInstall ?? true,
                currentVersion: "1.0.0",
                latestVersion: cfg.latestVersion ?? "1.2.3",
                body: null,
                date: null,
              }
            : {
                hasUpdate: false,
                readyToInstall: false,
                currentVersion: "1.0.0",
                latestVersion: null,
                body: null,
                date: null,
              };
        }

        if (command === "install_app_update") {
          if (cfg.slowInstall) {
            await new Promise<void>((resolve) => setTimeout(resolve, 3000));
          }
          return {
            installed: true,
            version: cfg.latestVersion ?? "1.2.3",
            message: "App update installed. Restart required.",
          };
        }

        if (command === "desktop_daemon_status") {
          return buildDaemonStatus();
        }

        if (command === "desktop_daemon_logs") {
          return { logPath: cfg.daemonLogPath ?? "", contents: "" };
        }

        if (command === "get_desktop_settings") {
          await waitForDesktopSettingsResponse();
          return {
            releaseChannel: "stable",
            daemon: { manageBuiltInDaemon: manageDaemon, keepRunningAfterQuit: true },
          };
        }

        if (command === "patch_desktop_settings") {
          const daemon = args?.daemon;
          if (
            daemon !== null &&
            typeof daemon === "object" &&
            "manageBuiltInDaemon" in daemon &&
            typeof daemon.manageBuiltInDaemon === "boolean"
          ) {
            manageDaemon = daemon.manageBuiltInDaemon;
          }
          return {
            releaseChannel: "stable",
            daemon: { manageBuiltInDaemon: manageDaemon, keepRunningAfterQuit: true },
          };
        }

        if (command === "stop_desktop_daemon") {
          daemonRunning = false;
          currentPid = null;
          return buildDaemonStatus();
        }

        if (command === "start_desktop_daemon") {
          return startDesktopDaemon();
        }

        return null;
      },
      dialog: {
        ask: async (message: string, options?: Record<string, unknown>) => {
          window.__capturedDialogCall = {
            message,
            title: typeof options?.title === "string" ? options.title : undefined,
          };
          return cfg.confirmShouldAccept ?? false;
        },
        open: async (options?: Record<string, unknown>) => {
          window.__capturedDialogOpenCalls.push(options);
          return cfg.dialogOpenResult ?? null;
        },
      },
      getPendingOpenProject: async () => null,
      events: { on: async () => () => undefined },
    };

    if (cfg.editorTargets) {
      desktopBridge.editor = {
        listTargets: async () => cfg.editorTargets ?? [],
        openTarget: async (input: DesktopEditorOpenRecord) => {
          await window.__recordDesktopEditorOpen?.(input);
        },
      };
    }

    window.__capturedDialogOpenCalls = [];
    (window as unknown as { paseoDesktop: unknown }).paseoDesktop = desktopBridge;
  }, config);
}

export async function waitForDesktopDaemonStartRequest(page: Page): Promise<void> {
  await page.waitForFunction(() => window.__desktopDaemonStartRequested === true);
  // Give the startup state two paints to expose any app → splash regression.
  await page.evaluate(
    () =>
      new Promise<void>((resolve) =>
        requestAnimationFrame(() => requestAnimationFrame(() => resolve())),
      ),
  );
}

export async function waitForDirectoryDialog(
  page: Page,
): Promise<Record<string, unknown> | undefined> {
  await expect.poll(() => page.evaluate(() => window.__capturedDialogOpenCalls.length)).toBe(1);
  return page.evaluate(() => window.__capturedDialogOpenCalls[0]);
}

export async function openDesktopSettings(page: Page, serverId: string): Promise<void> {
  await openSettings(page);
  await openSettingsHost(page, serverId);
  // The daemon-lifecycle card moved to the Host section in the flat-settings
  // layout; navigate there before asserting it.
  await openSettingsHostSection(page, serverId, "host");
  await expect(page.getByTestId("host-page-daemon-lifecycle-card")).toBeVisible({
    timeout: 15_000,
  });
}

export async function openDesktopAboutSettings(page: Page): Promise<void> {
  await openSettings(page);
  await openSettingsSection(page, "about");
  await expect(page.getByText("App updates", { exact: true })).toBeVisible();
}

export async function expectUpdateBanner(page: Page, version: string): Promise<void> {
  const callout = page.getByTestId("update-callout");
  await expect(callout).toBeVisible({ timeout: 15_000 });
  await expect(callout).toContainText(`v${version.replace(/^v/i, "")}`);
}

export async function clickCheckForUpdates(page: Page): Promise<void> {
  await page.getByRole("button", { name: "Check" }).click();
}

export async function expectPendingUpdateCheckResult(page: Page, version: string): Promise<void> {
  const normalizedVersion = `v${version.replace(/^v/i, "")}`;
  await expect(
    page.getByText(
      new RegExp(`Update found: ${escapeRegex(normalizedVersion)}\\. Downloading\\.\\.\\.`),
    ),
  ).toBeVisible();
  await expect(page.getByText(`Ready to install: ${normalizedVersion}`)).toHaveCount(0);
  await expect(page.getByRole("button", { name: "Update" })).toBeDisabled();
}

export async function clickInstallUpdate(page: Page): Promise<void> {
  await page.getByRole("button", { name: "Install & restart" }).click();
}

export async function expectInstallInProgress(page: Page): Promise<void> {
  await expect(page.getByRole("button", { name: "Installing..." })).toBeVisible();
}

/**
 * Clicks the daemon management switch and waits for dialog.ask to fire in the
 * mock, then returns the captured call args (message + title). The mock auto-
 * dismisses via confirmShouldAccept=false so callers can assert copy without
 * worrying about state changes.
 */
export async function interceptDaemonManagementConfirmDialog(
  page: Page,
): Promise<ConfirmDialogCall> {
  await page.getByRole("switch", { name: "Manage built-in daemon" }).click();
  await page.waitForFunction(() => !!window.__capturedDialogCall, { timeout: 5_000 });
  return page.evaluate(() => window.__capturedDialogCall!);
}

export async function toggleDaemonManagement(
  page: Page,
  _action: "enable" | "disable",
): Promise<void> {
  await page.getByRole("switch", { name: "Manage built-in daemon" }).click();
}

export function expectDaemonManagementConfirmDialog(args: ConfirmDialogCall): void {
  expect(args.title).toBe("Pause built-in daemon");
  expect(args.message).toContain("stop the built-in daemon immediately");
}

export async function expectDaemonManagementEnabled(page: Page): Promise<void> {
  await expect(page.getByRole("switch", { name: "Manage built-in daemon" })).toBeChecked();
}

export async function expectDaemonManagementDisabled(page: Page): Promise<void> {
  await expect(page.getByRole("switch", { name: "Manage built-in daemon" })).not.toBeChecked();
}

/**
 * Asserts the daemon status card shows the given PID. Pass null to assert
 * the cleared state (shown as "PID —" when the daemon is stopped).
 */
export async function expectDaemonStatusPid(page: Page, pid: number | null): Promise<void> {
  const expected = pid !== null ? `PID ${pid}` : "PID —";
  await expect(
    page.getByTestId("host-page-daemon-lifecycle-card").getByText(expected),
  ).toBeVisible();
}

export async function expectDaemonStatusLogPath(page: Page, logPath: string): Promise<void> {
  await expect(
    page.getByTestId("host-page-daemon-lifecycle-card").getByText(logPath),
  ).toBeVisible();
}

/**
 * Asserts the host page identity badge shows the given version string.
 * The badge is populated from the live WebSocket session's serverInfo.version.
 */
export async function expectDaemonStatusVersion(page: Page, version: string): Promise<void> {
  await expect(
    page.getByTestId("host-page-identity").getByText(version, { exact: false }),
  ).toBeVisible({ timeout: 15_000 });
}