/**
 * Example Handler - Demonstrates ergonomic handler patterns
 * Shows inline operations, service helpers, and scheduled operations
 */

import {
  BaseHandler,
  Disabled,
  Handler,
  Operation,
  ScheduledOperation,
  type ExecutionContext,
  type IServiceContainer,
} from '@stock-bot/handlers';

@Handler('example')
@Disabled()
export class ExampleHandler extends BaseHandler {
  constructor(services: IServiceContainer) {
    super(services);
  }

  /**
   * Simple inline operation - no separate action file needed
   */
  @Operation('get-stats')
  async getStats(): Promise<{ total: number; active: number; cached: boolean }> {
    // Use collection helper for cleaner MongoDB access
    const total = await this.collection('items').countDocuments();
    const active = await this.collection('items').countDocuments({ status: 'active' });

    // Use cache helpers with automatic prefixing
    const cached = await this.cacheGet<number>('last-total');
    await this.cacheSet('last-total', total, 300); // 5 minutes

    // Use log helper with automatic handler context
    this.log('info', 'Stats retrieved', { total, active });

    return { total, active, cached: cached !== null };
  }

  /**
   * Scheduled operation using combined decorator
   */
  @ScheduledOperation('cleanup-old-items', '0 2 * * *', {
    priority: 5,
    description: 'Clean up items older than 30 days',
  })
  async cleanupOldItems(): Promise<{ deleted: number }> {
    const thirtyDaysAgo = new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);

    const result = await this.collection('items').deleteMany({
      createdAt: { $lt: thirtyDaysAgo },
    });

    this.log('info', 'Cleanup completed', { deleted: result.deletedCount });

    // Schedule a follow-up task
    await this.scheduleIn('generate-report', { type: 'cleanup' }, 60); // 1 minute

    return { deleted: result.deletedCount };
  }

  /**
   * Operation that uses proxy service
   */
  @Operation('fetch-external-data')
  async fetchExternalData(input: { url: string }): Promise<{ data: any }> {
    const proxyUrl = this.proxy.getProxy();

    if (!proxyUrl) {
      throw new Error('No proxy available');
    }

    // Use HTTP client with proxy
    const response = await this.http.get(input.url, {
      proxy: proxyUrl,
      timeout: 10000,
    });

    // Cache the result
    await this.cacheSet(`external:${input.url}`, response.data, 3600);

    return { data: response.data };
  }

  /**
   * Complex operation that still uses action file
   */
  @Operation('process-batch')
  async processBatch(input: any, _context: ExecutionContext): Promise<unknown> {
    // For complex operations, still use action files
    const { processBatch } = await import('./actions/batch.action');
    return processBatch(this, input);
  }
}
