/**
 * Interactive Brokers Provider for new queue system
 */
import { getLogger } from '@stock-bot/logger';
import {
  createJobHandler,
  handlerRegistry,
  type HandlerConfigWithSchedule,
} from '@stock-bot/queue';
import type { ServiceContainer } from '@stock-bot/connection-factory';

const logger = getLogger('ib-provider');

// Initialize and register the IB provider
export function initializeIBProvider(container: ServiceContainer) {
  logger.debug('Registering IB provider with scheduled jobs...');

  const ibProviderConfig: HandlerConfigWithSchedule = {
    name: 'ib',
    operations: {
      'fetch-session': createJobHandler(async () => {
        // payload contains session configuration (not used in current implementation)
        logger.debug('Processing session fetch request');
        const { fetchSession } = await import('./operations/session.operations');
        return fetchSession(container);
      }),

      'fetch-exchanges': createJobHandler(async () => {
        // payload should contain session headers
        logger.debug('Processing exchanges fetch request');
        const { fetchSession } = await import('./operations/session.operations');
        const { fetchExchanges } = await import('./operations/exchanges.operations');
        const sessionHeaders = await fetchSession(container);
        if (sessionHeaders) {
          return fetchExchanges(sessionHeaders, container);
        }
        throw new Error('Failed to get session headers');
      }),

      'fetch-symbols': createJobHandler(async () => {
        // payload should contain session headers
        logger.debug('Processing symbols fetch request');
        const { fetchSession } = await import('./operations/session.operations');
        const { fetchSymbols } = await import('./operations/symbols.operations');
        const sessionHeaders = await fetchSession(container);
        if (sessionHeaders) {
          return fetchSymbols(sessionHeaders, container);
        }
        throw new Error('Failed to get session headers');
      }),

      'ib-exchanges-and-symbols': createJobHandler(async () => {
        // Legacy operation for scheduled jobs
        logger.info('Fetching symbol summary from IB');
        const { fetchSession } = await import('./operations/session.operations');
        const { fetchExchanges } = await import('./operations/exchanges.operations');
        const { fetchSymbols } = await import('./operations/symbols.operations');

        const sessionHeaders = await fetchSession(container);
        logger.info('Fetched symbol summary from IB');

        if (sessionHeaders) {
          logger.debug('Fetching exchanges from IB');
          const exchanges = await fetchExchanges(sessionHeaders, container);
          logger.info('Fetched exchanges from IB', { count: exchanges?.length });

          logger.debug('Fetching symbols from IB');
          const symbols = await fetchSymbols(sessionHeaders, container);
          logger.info('Fetched symbols from IB', { symbols });

          return { exchangesCount: exchanges?.length, symbolsCount: symbols?.length };
        }
        return null;
      }),
    },
    scheduledJobs: [
      {
        type: 'ib-exchanges-and-symbols',
        operation: 'ib-exchanges-and-symbols',
        cronPattern: '0 0 * * 0', // Every Sunday at midnight
        priority: 5,
        description: 'Fetch and update IB exchanges and symbols data',
        // immediately: true, // Don't run immediately during startup to avoid conflicts
      },
    ],
  };

  handlerRegistry.registerWithSchedule(ibProviderConfig);
  logger.debug('IB provider registered successfully with scheduled jobs');
}