import { ipcMain } from "electron";
import type { HandlerContext } from "@shared/types/ipc";
import { FEATURES } from "@shared/featureFlags";
import { agentService } from "../services/engines/unifiedAgent";
import { mcpProxyManager } from "../services/packages/mcp";
import { getComputerServerStatus } from "../services/computerServer";
import { getGuiAgentServerStatus } from "../services/packages/guiAgentServer";
import { getWindowsMcpStatus } from "../services/packages/windowsMcp";
import { isWindows } from "../services/system/shellEnv";
import {
  recordDigitalEmployeeSnapshot,
  recordDigitalEmployeeGovernanceCommand,
  readDigitalEmployeeRuntimeRecords,
  readDigitalEmployeeState,
  readDigitalEmployeeUiState,
  saveDigitalEmployeeUiState,
  type DigitalEmployeeGovernanceCommandRecord,
  type DigitalEmployeeServiceStatus,
  type DigitalEmployeeSnapshot,
  type DigitalEmployeeUiStateUpdate,
} from "../services/digitalEmployee/stateService";
import {
  flushDigitalEmployeeSyncOutbox,
  getDigitalEmployeeSyncStatus,
} from "../services/digitalEmployee/syncService";
import { listDigitalEmployeePlanTemplates } from "../services/digitalEmployee/planTemplateService";
import { listDigitalEmployeeSkillCapabilities } from "../services/digitalEmployee/skillCatalogService";

export function registerDigitalEmployeeHandlers(ctx: HandlerContext): void {
  ipcMain.handle("digitalEmployee:getSnapshot", async () => {
    const snapshot = buildSnapshot(ctx);
    const state = recordDigitalEmployeeSnapshot(snapshot);
    return {
      ...snapshot,
      state: {
        updatedAt: state.updatedAt,
        events: state.events,
      },
    };
  });

  ipcMain.handle("digitalEmployee:getState", async () => {
    return readDigitalEmployeeState();
  });

  ipcMain.handle("digitalEmployee:getRuntimeRecords", async () => {
    return readDigitalEmployeeRuntimeRecords();
  });

  ipcMain.handle("digitalEmployee:getUiState", async () => {
    return readDigitalEmployeeUiState();
  });

  ipcMain.handle("digitalEmployee:getSkillCapabilities", async () => {
    return listDigitalEmployeeSkillCapabilities();
  });

  ipcMain.handle("digitalEmployee:getPlanTemplates", async () => {
    return listDigitalEmployeePlanTemplates();
  });

  ipcMain.handle(
    "digitalEmployee:saveUiState",
    async (_, update: DigitalEmployeeUiStateUpdate) => {
      return saveDigitalEmployeeUiState(update);
    },
  );

  ipcMain.handle("digitalEmployee:getSyncStatus", async () => {
    return getDigitalEmployeeSyncStatus();
  });

  ipcMain.handle("digitalEmployee:flushSync", async () => {
    return flushDigitalEmployeeSyncOutbox({ force: true });
  });

  ipcMain.handle(
    "digitalEmployee:recordGovernanceCommand",
    async (_, command: DigitalEmployeeGovernanceCommandRecord) => {
      return recordDigitalEmployeeGovernanceCommand(command);
    },
  );
}

function buildSnapshot(ctx: HandlerContext): DigitalEmployeeSnapshot {
  const sessions = agentService.listAllSessionsDetailed();
  return {
    generatedAt: new Date().toISOString(),
    services: {
      agent: {
        running: agentService.isReady,
        engineType: agentService.getEngineType(),
      },
      mcp: normalizeServiceStatus(mcpProxyManager.getStatus()),
      computerServer: normalizeServiceStatus(getComputerServerStatus()),
      lanproxy: normalizeServiceStatus(ctx.lanproxy.status()),
      fileServer: normalizeServiceStatus(ctx.fileServer.status()),
      guiServer: normalizeServiceStatus(getGuiStatus()),
    },
    sessions: {
      total: sessions.length,
      active: sessions.filter((session) =>
        session.status === "active" || session.status === "pending",
      ).length,
      items: sessions.slice(0, 10),
    },
  };
}

function normalizeServiceStatus(
  value: object | null | undefined,
): DigitalEmployeeServiceStatus {
  if (!value) return { running: false };
  const record = value as Record<string, unknown>;
  return {
    running: record.running === true,
    error: typeof record.error === "string" ? record.error : undefined,
    engineType: typeof record.engineType === "string" ? record.engineType : undefined,
    port: typeof record.port === "number" ? record.port : undefined,
    serverCount: typeof record.serverCount === "number" ? record.serverCount : undefined,
    serverNames: Array.isArray(record.serverNames)
      ? record.serverNames.filter((item): item is string => typeof item === "string")
      : undefined,
    pid: typeof record.pid === "number" ? record.pid : undefined,
  };
}

function getGuiStatus(): object {
  if (!FEATURES.ENABLE_GUI_AGENT_SERVER) {
    return { running: false, error: "GUI Agent Server is not available" };
  }
  return isWindows() ? getWindowsMcpStatus() : getGuiAgentServerStatus();
}