/**
 * Data provider configurations using Yup
 */
import { cleanEnv, envValidators } from './env-utils';

const { str, num, bool, strWithChoices } = envValidators;

export interface ProviderConfig { 
  name: string;
  type: 'rest' | 'websocket';
  enabled: boolean;
  baseUrl?: string;
  apiKey?: string;
  apiSecret?: string;
  rateLimits?: {
    maxRequestsPerMinute?: number;
    maxRequestsPerSecond?: number;
    maxRequestsPerHour?: number;
  };
}
/**
 * Data providers configuration with validation and defaults
 */
export const dataProvidersConfig = cleanEnv(process.env, {
  // Default Provider
  DEFAULT_DATA_PROVIDER: strWithChoices(['alpaca', 'polygon', 'yahoo', 'iex'], 'alpaca', 'Default data provider'),
  
  // Alpaca Configuration
  ALPACA_API_KEY: str('', 'Alpaca API key'),
  ALPACA_API_SECRET: str('', 'Alpaca API secret'),
  ALPACA_BASE_URL: str('https://data.alpaca.markets/v1beta1', 'Alpaca base URL'),
  ALPACA_RATE_LIMIT: num(200, 'Alpaca rate limit per minute'),
  ALPACA_ENABLED: bool(true, 'Enable Alpaca provider'),
  
  // Polygon Configuration
  POLYGON_API_KEY: str('', 'Polygon API key'),
  POLYGON_BASE_URL: str('https://api.polygon.io', 'Polygon base URL'),
  POLYGON_RATE_LIMIT: num(5, 'Polygon rate limit per minute'),
  POLYGON_ENABLED: bool(false, 'Enable Polygon provider'),
  
  // Yahoo Finance Configuration
  YAHOO_BASE_URL: str('https://query1.finance.yahoo.com', 'Yahoo Finance base URL'),
  YAHOO_RATE_LIMIT: num(2000, 'Yahoo Finance rate limit per hour'),
  YAHOO_ENABLED: bool(true, 'Enable Yahoo Finance provider'),
  
  // IEX Cloud Configuration
  IEX_API_KEY: str('', 'IEX Cloud API key'),
  IEX_BASE_URL: str('https://cloud.iexapis.com/stable', 'IEX Cloud base URL'),
  IEX_RATE_LIMIT: num(100, 'IEX Cloud rate limit per second'),
  IEX_ENABLED: bool(false, 'Enable IEX Cloud provider'),
  
  // Connection Settings
  DATA_PROVIDER_TIMEOUT: num(30000, 'Request timeout in milliseconds'),
  DATA_PROVIDER_RETRIES: num(3, 'Number of retry attempts'),
  DATA_PROVIDER_RETRY_DELAY: num(1000, 'Retry delay in milliseconds'),
  
  // Cache Settings
  DATA_CACHE_ENABLED: bool(true, 'Enable data caching'),
  DATA_CACHE_TTL: num(300000, 'Cache TTL in milliseconds'),
  DATA_CACHE_MAX_SIZE: num(1000, 'Maximum cache entries'),
});

/**
 * Helper function to get provider-specific configuration
 */
export function getProviderConfig(providerName: string) {
  // make a interface for the provider config

  const name = providerName.toUpperCase();
  
  switch (name) {
    case 'ALPACA':
      return {
        name: 'alpaca',
        type: 'rest' as const,
        enabled: dataProvidersConfig.ALPACA_ENABLED,
        baseUrl: dataProvidersConfig.ALPACA_BASE_URL,
        apiKey: dataProvidersConfig.ALPACA_API_KEY,
        apiSecret: dataProvidersConfig.ALPACA_API_SECRET,
        rateLimits: {
          maxRequestsPerMinute: dataProvidersConfig.ALPACA_RATE_LIMIT
        }
      };
    
    case 'POLYGON':
      return {
        name: 'polygon',
        type: 'rest' as const,
        enabled: dataProvidersConfig.POLYGON_ENABLED,
        baseUrl: dataProvidersConfig.POLYGON_BASE_URL,
        apiKey: dataProvidersConfig.POLYGON_API_KEY,
        rateLimits: {
          maxRequestsPerMinute: dataProvidersConfig.POLYGON_RATE_LIMIT
        }
      };
    
    case 'YAHOO':
      return {
        name: 'yahoo',
        type: 'rest' as const,
        enabled: dataProvidersConfig.YAHOO_ENABLED,
        baseUrl: dataProvidersConfig.YAHOO_BASE_URL,
        rateLimits: {
          maxRequestsPerHour: dataProvidersConfig.YAHOO_RATE_LIMIT
        }
      };
    
    case 'IEX':
      return {
        name: 'iex',
        type: 'rest' as const,
        enabled: dataProvidersConfig.IEX_ENABLED,
        baseUrl: dataProvidersConfig.IEX_BASE_URL,
        apiKey: dataProvidersConfig.IEX_API_KEY,
        rateLimits: {
          maxRequestsPerSecond: dataProvidersConfig.IEX_RATE_LIMIT
        }
      };
    
    default:
      throw new Error(`Unknown provider: ${providerName}`);
  }
}

/**
 * Get all enabled providers
 */
export function getEnabledProviders() {
  const providers = ['alpaca', 'polygon', 'yahoo', 'iex'];
  return providers
    .map(provider => getProviderConfig(provider))
    .filter(config => config.enabled);
}

/**
 * Get the default provider configuration
 */
export function getDefaultProvider() {
  return getProviderConfig(dataProvidersConfig.DEFAULT_DATA_PROVIDER);
}

// Export typed configuration object
export type DataProvidersConfig = typeof dataProvidersConfig;
export class DataProviders {
  static getProviderConfig(providerName: string): ProviderConfig {
    return getProviderConfig(providerName);
  }

  static getEnabledProviders(): ProviderConfig[] {
    return getEnabledProviders();
  }

  static getDefaultProvider(): ProviderConfig {
    return getDefaultProvider();
  }
}


// Export individual config values for convenience
export const {
  DEFAULT_DATA_PROVIDER,
  ALPACA_API_KEY,
  ALPACA_API_SECRET,
  ALPACA_BASE_URL,
  ALPACA_RATE_LIMIT,
  ALPACA_ENABLED,
  POLYGON_API_KEY,
  POLYGON_BASE_URL,
  POLYGON_RATE_LIMIT,
  POLYGON_ENABLED,
  YAHOO_BASE_URL,
  YAHOO_RATE_LIMIT,
  YAHOO_ENABLED,
  IEX_API_KEY,
  IEX_BASE_URL,
  IEX_RATE_LIMIT,
  IEX_ENABLED,
  DATA_PROVIDER_TIMEOUT,
  DATA_PROVIDER_RETRIES,
  DATA_PROVIDER_RETRY_DELAY,
  DATA_CACHE_ENABLED,
  DATA_CACHE_TTL,
  DATA_CACHE_MAX_SIZE,
} = dataProvidersConfig;