/**
 * Factory utilities for creating AI providers
 * Provides convenient methods for instantiating and configuring providers
 */

import type { AIProviderConfig } from '../types/index.js';
import { ClaudeProvider, type ClaudeConfig } from '../providers/claude.js';
import { BaseAIProvider } from '../providers/base.js';

/**
 * Supported AI provider types
 */
export type ProviderType = 'claude';

/**
 * Configuration map for different provider types
 */
export interface ProviderConfigMap {
  claude: ClaudeConfig;
}

/**
 * Factory function to create AI providers
 * @param type - The type of provider to create
 * @param config - Configuration for the provider
 * @returns Configured AI provider instance
 */
export function createProvider<T extends ProviderType>(
  type: T,
  config: ProviderConfigMap[T]
): BaseAIProvider {
  switch (type) {
    case 'claude':
      return new ClaudeProvider(config as ClaudeConfig);
    default:
      throw new Error(`Unsupported provider type: ${type}`);
  }
}

/**
 * Create a Claude provider with simplified configuration
 * @param apiKey - Anthropic API key
 * @param options - Optional additional configuration
 * @returns Configured Claude provider instance
 */
export function createClaudeProvider(
  apiKey: string,
  options: Partial<Omit<ClaudeConfig, 'apiKey'>> = {}
): ClaudeProvider {
  return new ClaudeProvider({
    apiKey,
    ...options
  });
}

/**
 * Provider registry for dynamic provider creation
 */
export class ProviderRegistry {
  private static providers = new Map<string, new (config: AIProviderConfig) => BaseAIProvider>();

  /**
   * Register a new provider type
   * @param name - Name of the provider
   * @param providerClass - Provider class constructor
   */
  static register(name: string, providerClass: new (config: AIProviderConfig) => BaseAIProvider): void {
    this.providers.set(name.toLowerCase(), providerClass);
  }

  /**
   * Create a provider by name
   * @param name - Name of the provider
   * @param config - Configuration for the provider
   * @returns Provider instance
   */
  static create(name: string, config: AIProviderConfig): BaseAIProvider {
    const ProviderClass = this.providers.get(name.toLowerCase());
    if (!ProviderClass) {
      throw new Error(`Provider '${name}' is not registered`);
    }
    return new ProviderClass(config);
  }

  /**
   * Get list of registered provider names
   * @returns Array of registered provider names
   */
  static getRegisteredProviders(): string[] {
    return Array.from(this.providers.keys());
  }

  /**
   * Check if a provider is registered
   * @param name - Name of the provider
   * @returns True if provider is registered
   */
  static isRegistered(name: string): boolean {
    return this.providers.has(name.toLowerCase());
  }
}

// Pre-register built-in providers
ProviderRegistry.register('claude', ClaudeProvider);