import { contextBridge, ipcRenderer, type IpcRendererEvent } from "electron";
import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
import type { Project } from "./db/projects";
import type { Session, Message } from "./db/sessions";
import type { Phase, UserPermissionMode } from "./claude/phases";

export interface ClaudeFlowAPI {
  // Projects
  listProjects: () => Promise<Project[]>;
  createProject: (name: string, path: string) => Promise<Project>;
  deleteProject: (id: string) => Promise<void>;

  // Sessions
  listSessions: (projectId: string) => Promise<Session[]>;
  createSession: (projectId: string, name: string, phase?: Phase) => Promise<Session>;
  deleteSession: (id: string) => Promise<void>;
  getSession: (id: string) => Promise<Session | undefined>;
  renameSession: (id: string, name: string) => Promise<void>;

  // Messages
  listMessages: (sessionId: string) => Promise<Message[]>;

  // Chat
  sendMessage: (sessionId: string, message: string) => Promise<void>;
  interruptSession: (sessionId: string) => Promise<void>;

  // Workflow
  triggerReview: (sessionId: string) => Promise<void>;
  advancePhase: (sessionId: string) => Promise<{ phase: Phase; git_branch: string | null } | null>;
  setPermissionMode: (
    sessionId: string,
    mode: UserPermissionMode
  ) => Promise<void>;

  // Session Artifacts (stored in ~/.claude-flow/)
  readSessionArtifact: (
    projectId: string,
    sessionId: string,
    filename: string
  ) => Promise<string | null>;
  writeSessionArtifact: (
    projectId: string,
    sessionId: string,
    filename: string,
    content: string
  ) => Promise<void>;

  // CLAUDE.md (stored in project)
  readClaudeMd: (projectPath: string) => Promise<string | null>;
  writeClaudeMd: (projectPath: string, content: string) => Promise<void>;

  // Events
  onClaudeMessage: (
    callback: (sessionId: string, message: SDKMessage) => void
  ) => () => void;

  // Settings
  getSettings: (keys: string[]) => Promise<Record<string, string | null>>;
  setSetting: (key: string, value: string) => Promise<void>;
  deleteSetting: (key: string) => Promise<void>;
  getDefaultSystemPrompts: () => Promise<Record<"research" | "plan" | "implement", string>>;

  // Dialogs
  selectDirectory: () => Promise<string | null>;

  // MCP
  discoverMcpTools: (config: {
    type: "stdio" | "sse" | "http";
    command?: string;
    args?: string[];
    env?: Record<string, string>;
    url?: string;
  }) => Promise<{ tools: Array<{ name: string; description?: string }>; error?: string }>;

  // Window
  toggleMaximize: () => Promise<void>;
  onWindowMaximized: (cb: (isMaximized: boolean) => void) => () => void;
}

const api: ClaudeFlowAPI = {
  // Projects
  listProjects: () => ipcRenderer.invoke("projects:list"),
  createProject: (name, path) =>
    ipcRenderer.invoke("projects:create", name, path),
  deleteProject: (id) => ipcRenderer.invoke("projects:delete", id),

  // Sessions
  listSessions: (projectId) => ipcRenderer.invoke("sessions:list", projectId),
  createSession: (projectId, name, phase) =>
    ipcRenderer.invoke("sessions:create", projectId, name, phase),
  deleteSession: (id) => ipcRenderer.invoke("sessions:delete", id),
  getSession: (id) => ipcRenderer.invoke("sessions:get", id),
  renameSession: (id, name) => ipcRenderer.invoke("sessions:rename", id, name),

  // Messages
  listMessages: (sessionId) => ipcRenderer.invoke("messages:list", sessionId),

  // Chat
  sendMessage: (sessionId, message) =>
    ipcRenderer.invoke("chat:send", sessionId, message),
  interruptSession: (sessionId) =>
    ipcRenderer.invoke("chat:interrupt", sessionId),

  // Workflow
  triggerReview: (sessionId) => ipcRenderer.invoke("workflow:review", sessionId),
  advancePhase: (sessionId) => ipcRenderer.invoke("workflow:advance", sessionId),
  setPermissionMode: (sessionId, mode) =>
    ipcRenderer.invoke("workflow:setPermissionMode", sessionId, mode),

  // Session Artifacts (stored in ~/.claude-flow/)
  readSessionArtifact: (projectId, sessionId, filename) =>
    ipcRenderer.invoke("artifact:readSession", projectId, sessionId, filename),
  writeSessionArtifact: (projectId, sessionId, filename, content) =>
    ipcRenderer.invoke("artifact:writeSession", projectId, sessionId, filename, content),

  // CLAUDE.md (stored in project)
  readClaudeMd: (projectPath) => ipcRenderer.invoke("claudemd:read", projectPath),
  writeClaudeMd: (projectPath, content) =>
    ipcRenderer.invoke("claudemd:write", projectPath, content),

  // Events
  onClaudeMessage: (callback) => {
    const handler = (
      _: IpcRendererEvent,
      sessionId: string,
      message: SDKMessage
    ) => callback(sessionId, message);
    ipcRenderer.on("claude:message", handler);
    return () => ipcRenderer.removeListener("claude:message", handler);
  },

  // Settings
  getSettings: (keys) => ipcRenderer.invoke("settings:get", keys),
  setSetting: (key, value) => ipcRenderer.invoke("settings:set", key, value),
  deleteSetting: (key) => ipcRenderer.invoke("settings:delete", key),
  getDefaultSystemPrompts: () => ipcRenderer.invoke("settings:getDefaultPrompts"),

  // Dialogs
  selectDirectory: async () => {
    const result = await ipcRenderer.invoke("dialog:selectDirectory");
    return result;
  },

  // MCP
  discoverMcpTools: (config) => ipcRenderer.invoke("mcp:discoverTools", config),

  // Window
  toggleMaximize: () => ipcRenderer.invoke("window:toggleMaximize"),
  onWindowMaximized: (cb) => {
    const handler = (_: IpcRendererEvent, val: boolean) => cb(val);
    ipcRenderer.on("window:maximized", handler);
    return () => ipcRenderer.removeListener("window:maximized", handler);
  },
};

contextBridge.exposeInMainWorld("api", api);

// Type declaration for renderer
declare global {
  interface Window {
    api: ClaudeFlowAPI;
  }
}