AI Providers

export function getActiveProvider(): AIProvider | null {
  // If provider is explicitly set, use it (AI_API_KEY can serve as its key)
  if (aiConfig.AI_PROVIDER) {
    return aiConfig.AI_PROVIDER
  }

  // Auto-detect based on available API keys (Anthropic preferred)
  if (aiConfig.ANTHROPIC_API_KEY) return 'anthropic'
  if (aiConfig.OPENAI_API_KEY) return 'openai'
  if (aiConfig.GOOGLE_AI_API_KEY) return 'google'
  if (aiConfig.XAI_API_KEY) return 'xai'

  return null
}

# Force Anthropic even if OpenAI key is also present
AI_PROVIDER=anthropic

export const MODEL_ALIASES: Record<string, string> = {
  // OpenAI aliases
  gpt5: 'gpt-5',
  'gpt5.2': 'gpt-5.2',
  'gpt5-mini': 'gpt-5-mini',
  'gpt5-nano': 'gpt-5-nano',
  gpt4: 'gpt-4.1',
  'gpt4-mini': 'gpt-4.1-mini',
  'gpt-4': 'gpt-4.1',
  o3: 'o3',
  'o4-mini': 'o4-mini',

  // Anthropic aliases
  claude: 'claude-sonnet-4-5-20250929',
  'claude-opus': 'claude-opus-4-6-20260205',
  'claude-sonnet': 'claude-sonnet-4-5-20250929',
  'claude-haiku': 'claude-haiku-4-5-20251001',
  opus: 'claude-opus-4-6-20260205',
  sonnet: 'claude-sonnet-4-5-20250929',
  haiku: 'claude-haiku-4-5-20251001',

  // Google aliases
  gemini: 'gemini-2.5-flash',
  'gemini-pro': 'gemini-2.5-pro',
  'gemini-flash': 'gemini-2.5-flash',
  'gemini-lite': 'gemini-2.5-flash-lite',
  'gemini-3': 'gemini-3-flash-preview',

  // xAI aliases
  grok: 'grok-4-1-fast-reasoning',
  'grok-code': 'grok-code-fast-1',
  'grok-fast': 'grok-4-fast-reasoning',
  'grok-4.1': 'grok-4-1-fast-reasoning',
}

export function createAIProvider(config: ProviderConfig): BaseProvider {
  // Validate configuration
  const validation = ProviderConfigSchema.safeParse(config)

  if (!validation.success) {
    const errors = validation.error.issues.map((err) => ({
      field: err.path.join('.'),
      message: err.message,
    }))
    throw new ValidationError('Invalid provider configuration', errors)
  }

  const validatedConfig = validation.data

  // Check cache
  const cacheKey = createCacheKey(validatedConfig)
  const cached = providerCache.get(cacheKey)
  if (cached) {
    return cached
  }

  // Create new provider instance
  let provider: BaseProvider

  switch (validatedConfig.provider) {
    case 'openai':
      provider = new OpenAIProvider(validatedConfig)
      break

    case 'anthropic':
      provider = new AnthropicProvider(validatedConfig)
      break

    case 'google':
      provider = new GoogleProvider(validatedConfig)
      break

    case 'xai':
      provider = new XAIProvider(validatedConfig)
      break

    default:
      // This should never happen due to validation, but TypeScript needs it
      throw new InvalidProviderError(validatedConfig.provider)
  }

  // Cache the provider instance
  providerCache.set(cacheKey, provider)

  return provider
}

export interface ProviderRequirements {
  needsVision?: boolean
  needsEmbeddings?: boolean
  needsFunctions?: boolean
  needsLargeContext?: boolean
  preferCheap?: boolean
  preferFast?: boolean
}

/**
 * Select the best provider based on requirements
 */
export function selectProvider(
  requirements: ProviderRequirements = {}
): AIProvider {
  const available = getAvailableProviders()

  if (available.length === 0) {
    throw new ValidationError('No AI providers configured', [
      {
        field: 'API_KEYS',
        message: 'At least one provider API key must be set',
      },
    ])
  }

  // Score each provider based on requirements
  const scores: Record<AIProvider, number> = {
    openai: 0,
    anthropic: 0,
    google: 0,
    xai: 0,
  }

  for (const provider of available) {
    let score = 10 // Base score for being available

    if (requirements.needsVision) {
      if (
        provider === 'openai' ||
        provider === 'anthropic' ||
        provider === 'google'
      ) {
        score += 5
      }
    }

    if (requirements.needsEmbeddings) {
      if (provider === 'openai' || provider === 'google') {
        score += 5
      }
    }

    if (requirements.needsFunctions) {
      // All providers support functions
      score += 1
    }

    if (requirements.needsLargeContext) {
      if (provider === 'anthropic' || provider === 'google') {
        score += 5 // Both have 1M+ context windows
      }
    }

    if (requirements.preferCheap) {
      if (provider === 'google') {
        score += 10 // Gemini Flash is very cheap
      } else if (provider === 'openai') {
        score += 5 // GPT-4o-mini is cheap
      }
    }

    if (requirements.preferFast) {
      if (provider === 'openai' || provider === 'google') {
        score += 5
      }
    }

    scores[provider] = score
  }

  // Find provider with highest score
  let bestProvider: AIProvider = available[0]
  let bestScore = scores[bestProvider]

  for (const provider of available) {
    if (scores[provider] > bestScore) {
      bestProvider = provider
      bestScore = scores[provider]
    }
  }

  return bestProvider
}

// Reasoning-aware parameter handling (openai.ts)
const isReasoning = modelInfo?.isReasoningModel === true
streamText({
  ...(isReasoning ? {} : { temperature: options.temperature ?? 0.7 }),
  maxTokens: options.maxTokens ?? (isReasoning ? 16384 : 1000),
})

export abstract class BaseProvider {
  protected readonly provider: AIProvider
  protected readonly apiKey: string
  protected readonly baseURL?: string
  protected readonly timeout: number
  protected readonly retryConfig: RetryConfig
  protected defaultModel: string
  protected defaultTemperature: number
  protected defaultMaxTokens: number

  constructor(config: ProviderConfig) {
    this.provider = config.provider
    this.apiKey = config.apiKey
    this.baseURL = config.baseURL
    this.timeout = config.timeout ?? 30000 // 30 seconds default
    this.defaultModel = config.model ?? this.getDefaultModel()
    this.defaultTemperature = config.defaultTemperature ?? 0.7
    this.defaultMaxTokens = config.defaultMaxTokens ?? 1000

    this.retryConfig = {
      maxRetries: config.maxRetries ?? 3,
      baseDelay: 1000,
      maxDelay: 10000,
      backoffFactor: 2,
    }
  }