import { getLogger } from '@stock-bot/logger';

export interface JobHandler {
  (payload: any): Promise<any>;
}

export interface JobData {
  type?: string;
  provider: string;
  operation: string;
  payload: any;
  priority?: number;
  immediately?: boolean;
}

export interface ScheduledJob {
  type: string;
  operation: string;
  payload: any;
  cronPattern: string;
  priority?: number;
  description?: string;
  immediately?: boolean;
}

export interface ProviderConfig {
  name: string;
  operations: Record<string, JobHandler>;
  scheduledJobs?: ScheduledJob[];
}

export class ProviderRegistry {
  private logger = getLogger('provider-registry');
  private providers = new Map<string, ProviderConfig>();

  /**
   * Register a provider with its operations
   */  
  registerProvider(config: ProviderConfig): void {
    // const key = `${config.service}:${config.name}`;
    this.providers.set(config.name, config);
    this.logger.info(`Registered provider: ${config.name}`, { 
      operations: Object.keys(config.operations),
      scheduledJobs: config.scheduledJobs?.length || 0
    });
  }
  /**
   * Get a job handler for a specific provider and operation
   */
  getHandler(provider: string, operation: string): JobHandler | null {
    const providerConfig = this.providers.get(provider);
    
    if (!providerConfig) {
      this.logger.warn(`Provider not found: ${provider}`);
      return null;
    }

    const handler = providerConfig.operations[operation];
    if (!handler) {
      this.logger.warn(`Operation not found: ${operation} in provider ${provider}`);
      return null;
    }

    return handler;
  }
  /**
   * Get all scheduled jobs from all providers
   */
  getAllScheduledJobs(): Array<{
    provider: string;
    job: ScheduledJob;
  }> {
    const allJobs: Array<{ provider: string; job: ScheduledJob }> = [];
    
    for (const [key, config] of this.providers) {
      if (config.scheduledJobs) {
        for (const job of config.scheduledJobs) {
          allJobs.push({
            provider: config.name,
            job
          });
        }
      }
    }
    
    return allJobs;
  }

  getProviders(): Array<{ key: string; config: ProviderConfig }> {
    return Array.from(this.providers.entries()).map(([key, config]) => ({
      key,
      config
    }));
  }
  /**
   * Check if a provider exists
   */
  hasProvider(provider: string): boolean {
    return this.providers.has(provider);
  }
  /**
   * Clear all providers (useful for testing)
   */
  clear(): void {
    this.providers.clear();
    this.logger.info('All providers cleared');
  }
}

export const providerRegistry = new ProviderRegistry();