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";
import type { GitWorktreeInfo } from "./git/worktree";

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) => Promise<Session>;
  deleteSession: (id: string) => Promise<void>;
  getSession: (id: string) => Promise<Session | undefined>;

  // 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 | null>;
  setPermissionMode: (
    sessionId: string,
    mode: UserPermissionMode
  ) => Promise<void>;

  // Session Artifacts (new session-specific)
  readSessionArtifact: (
    projectPath: string,
    sessionId: string,
    filename: string
  ) => Promise<string | null>;
  writeSessionArtifact: (
    projectPath: string,
    sessionId: string,
    filename: string,
    content: string
  ) => Promise<void>;

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

  // Legacy Artifacts (backward compat)
  readArtifact: (
    projectPath: string,
    filename: string
  ) => Promise<string | null>;
  writeArtifact: (
    projectPath: string,
    filename: string,
    content: string
  ) => Promise<void>;

  // Git
  isGitRepo: (projectPath: string) => Promise<boolean>;
  getWorktreeInfo: (projectPath: string, sessionId: string) => Promise<GitWorktreeInfo | null>;
  commitChanges: (worktreePath: string, message: string, files?: string[]) => Promise<void>;
  hasUncommittedChanges: (worktreePath: string) => Promise<boolean>;

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

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

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) =>
    ipcRenderer.invoke("sessions:create", projectId, name),
  deleteSession: (id) => ipcRenderer.invoke("sessions:delete", id),
  getSession: (id) => ipcRenderer.invoke("sessions:get", id),

  // 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
  readSessionArtifact: (projectPath, sessionId, filename) =>
    ipcRenderer.invoke("artifact:readSession", projectPath, sessionId, filename),
  writeSessionArtifact: (projectPath, sessionId, filename, content) =>
    ipcRenderer.invoke("artifact:writeSession", projectPath, sessionId, filename, content),

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

  // Legacy Artifacts
  readArtifact: (projectPath, filename) =>
    ipcRenderer.invoke("artifact:read", projectPath, filename),
  writeArtifact: (projectPath, filename, content) =>
    ipcRenderer.invoke("artifact:write", projectPath, filename, content),

  // Git
  isGitRepo: (projectPath) => ipcRenderer.invoke("git:isRepo", projectPath),
  getWorktreeInfo: (projectPath, sessionId) =>
    ipcRenderer.invoke("git:worktreeInfo", projectPath, sessionId),
  commitChanges: (worktreePath, message, files) =>
    ipcRenderer.invoke("git:commit", worktreePath, message, files),
  hasUncommittedChanges: (worktreePath) =>
    ipcRenderer.invoke("git:hasChanges", worktreePath),

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

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

contextBridge.exposeInMainWorld("api", api);

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