/**
 * AI Service - Main entry point for AI functionality
 */

import { createLogger } from "../../core/logger";
import { OpenRouterProvider } from "./openrouter";
import type { AiProvider, AiResponse, MessageStyle } from "./types";
import type { ToolContext } from "./tools";

const logger = createLogger("AI:Service");

export class AiService {
  private provider: AiProvider;

  constructor(provider?: AiProvider) {
    this.provider = provider ?? new OpenRouterProvider();
  }

  async health(): Promise<boolean> {
    return this.provider.health();
  }

  async generateResponse(
    prompt: string,
    systemPrompt: string
  ): Promise<AiResponse> {
    logger.debug("Generating response", { promptLength: prompt.length });
    return this.provider.ask({ prompt, systemPrompt });
  }

  /**
   * Generate a response with tool calling support
   * The AI can look up memories, save new ones, etc.
   */
  async generateResponseWithTools(
    prompt: string,
    systemPrompt: string,
    context: ToolContext
  ): Promise<AiResponse> {
    if (this.provider.askWithTools) {
      logger.debug("Generating response with tools", { promptLength: prompt.length });
      return this.provider.askWithTools({ prompt, systemPrompt, context });
    }
    // Fallback to regular response if tools not supported
    return this.generateResponse(prompt, systemPrompt);
  }

  /**
   * Classify a message to determine the appropriate response style
   */
  async classifyMessage(message: string): Promise<MessageStyle> {
    if (this.provider.classifyMessage) {
      return this.provider.classifyMessage(message);
    }
    // Default to snarky if provider doesn't support classification
    return "snarky";
  }

  /**
   * Extract and save memorable information from a message
   */
  async extractMemories(
    message: string,
    authorName: string,
    context: ToolContext
  ): Promise<void> {
    if (this.provider.extractMemories) {
      return this.provider.extractMemories(message, authorName, context);
    }
  }
}

// Singleton instance
let aiService: AiService | null = null;

export function getAiService(): AiService {
  if (!aiService) {
    aiService = new AiService();
  }
  return aiService;
}

export type { AiProvider, AiResponse, MessageStyle } from "./types";
export type { ToolContext, ToolCall, ToolResult } from "./tools";
export { JOEL_TOOLS, MEMORY_EXTRACTION_TOOLS } from "./tools";