import { getAmpSessionsStreaming } from "./amp";
import {
  CHAT_PROVIDER_IDS,
  type ChatProviderAdapter,
  type ChatProviderId,
  type ChatSession,
  stableMessageId,
} from "./chat-types";
import { getClaudeSessionsStreaming } from "./claude";
import { getClaudeDesktopSessionsStreaming } from "./claude-desktop";
import { getClineSessionsStreaming } from "./cline";
import { getCodexSessionsStreaming } from "./codex";
import { getCopilotSessionsStreaming } from "./copilot";
import { getGeminiSessionsStreaming } from "./gemini";
import { getGrokSessionsStreaming } from "./grok";
import { getOpenCodeSessionsStreaming } from "./opencode";

async function* streamClaudeSessions(
  scanRoots: string[],
  since?: Date,
): AsyncGenerator<ChatSession> {
  for await (const session of getClaudeSessionsStreaming(scanRoots, since)) {
    const messages = session.events.map((event, index) => ({
      externalMessageId:
        event.id ||
        stableMessageId(session.sessionId, index, `claude-${index}`),
      role: event.messageType,
      timestamp: event.timestamp,
      text: event.fullContent,
      rawJson: {
        conversationFile: event.conversationFile,
      },
    }));

    if (messages.length === 0) continue;

    yield {
      providerId: "claude",
      externalThreadId: session.sessionId,
      projectPath: session.projectPath,
      title: session.conversationFile,
      conversationFile: session.conversationFile,
      startedAt: messages[0]?.timestamp,
      endedAt: messages[messages.length - 1]?.timestamp,
      metadata: {
        projectPath: session.projectPath,
      },
      messages,
    };
  }
}

async function* streamCursorSessions(
  scanRoots: string[],
  since?: Date,
  options?: { workspaceStorageRoots?: string[] },
): AsyncGenerator<ChatSession> {
  const { getCursorSessionsStreaming } = await import("./cursor");
  yield* getCursorSessionsStreaming(scanRoots, since, options);
}

export const CHAT_PROVIDER_ADAPTERS: Record<
  ChatProviderId,
  ChatProviderAdapter
> = {
  claude: {
    providerId: "claude",
    scanRootType: "claude",
    streamSessions: streamClaudeSessions,
  },
  claude_desktop: {
    providerId: "claude_desktop",
    scanRootType: "claude_desktop",
    streamSessions: getClaudeDesktopSessionsStreaming,
  },
  gemini: {
    providerId: "gemini",
    scanRootType: "gemini",
    streamSessions: getGeminiSessionsStreaming,
  },
  codex: {
    providerId: "codex",
    scanRootType: "codex",
    streamSessions: getCodexSessionsStreaming,
  },
  opencode: {
    providerId: "opencode",
    scanRootType: "opencode",
    streamSessions: getOpenCodeSessionsStreaming,
  },
  cursor: {
    providerId: "cursor",
    scanRootType: "cursor",
    streamSessions: streamCursorSessions,
  },
  cline: {
    providerId: "cline",
    scanRootType: "cline",
    streamSessions: getClineSessionsStreaming,
  },
  amp: {
    providerId: "amp",
    scanRootType: "amp",
    streamSessions: getAmpSessionsStreaming,
  },
  copilot: {
    providerId: "copilot",
    scanRootType: "copilot",
    streamSessions: getCopilotSessionsStreaming,
  },
  grok: {
    providerId: "grok",
    scanRootType: "grok",
    streamSessions: getGrokSessionsStreaming,
  },
};

export function getChatProviderAdapter(
  providerId: ChatProviderId,
): ChatProviderAdapter {
  return CHAT_PROVIDER_ADAPTERS[providerId];
}

export function getAllChatProviderAdapters(): ChatProviderAdapter[] {
  return CHAT_PROVIDER_IDS.map((providerId) =>
    getChatProviderAdapter(providerId),
  );
}