import * as plugins from '../plugins.js';
import * as paths from '../paths.js';
import { MtaConnector } from './email.classes.connector.mta.js';
import { RuleManager } from './email.classes.rulemanager.js';
import { ApiManager } from './email.classes.apimanager.js';
import { logger } from '../logger.js';
import type { SzPlatformService } from '../classes.platformservice.js';

// Import MTA service
import { MtaService, type IMtaConfig } from '../mta/index.js';

export interface IEmailConstructorOptions {
  useMta?: boolean;
  mtaConfig?: IMtaConfig;
}

/**
 * Email service with support for both Mailgun and local MTA
 */
export class EmailService {
  public platformServiceRef: SzPlatformService;

  // typedrouter
  public typedrouter = new plugins.typedrequest.TypedRouter();

  // connectors
  public mtaConnector: MtaConnector;
  public qenv = new plugins.qenv.Qenv('./', '.nogit/');

  // MTA service
  public mtaService: MtaService;

  // services
  public apiManager: ApiManager;
  public ruleManager: RuleManager;

  // configuration
  private config: IEmailConstructorOptions;

  constructor(platformServiceRefArg: SzPlatformService, options: IEmailConstructorOptions = {}) {
    this.platformServiceRef = platformServiceRefArg;
    this.platformServiceRef.typedrouter.addTypedRouter(this.typedrouter);
    
    // Set default options
    this.config = {
      useMta: options.useMta ?? true,
      mtaConfig: options.mtaConfig || {}
    };

    if (this.config.useMta) {
      // Initialize MTA service
      this.mtaService = new MtaService(platformServiceRefArg, this.config.mtaConfig);
      // Initialize MTA connector
      this.mtaConnector = new MtaConnector(this);
    }

    // Initialize API manager and rule manager
    this.apiManager = new ApiManager(this);
    this.ruleManager = new RuleManager(this);

    // Set up MTA SMTP server webhook if using MTA
    if (this.config.useMta) {
      // The MTA SMTP server will handle incoming emails directly
      // through its SMTP protocol. No additional webhook needed.
    }
  }

  /**
   * Start the email service
   */
  public async start() {
    // Initialize rule manager
    await this.ruleManager.init();
    
    // Start MTA service if enabled
    if (this.config.useMta && this.mtaService) {
      await this.mtaService.start();
      logger.log('success', 'Started MTA service');
    }
    
    logger.log('success', `Started email service`);
  }

  /**
   * Stop the email service
   */
  public async stop() {
    // Stop MTA service if it's running
    if (this.config.useMta && this.mtaService) {
      await this.mtaService.stop();
      logger.log('info', 'Stopped MTA service');
    }
    
    logger.log('info', 'Stopped email service');
  }

  /**
   * Send an email using the configured provider (Mailgun or MTA)
   * @param email The email to send
   * @param to Recipient(s)
   * @param options Additional options
   */
  public async sendEmail(
    email: plugins.smartmail.Smartmail<>,
    to: string | string[],
    options: any = {}
  ): Promise<string> {
    // Determine which connector to use
    if (this.config.useMta && this.mtaConnector) {
      return this.mtaConnector.sendEmail(email, to, options);
    } else {
      throw new Error('No email provider configured');
    }
  }

  /**
   * Get email service statistics
   */
  public getStats() {
    const stats: any = {
      activeProviders: []
    };

    if (this.config.useMta) {
      stats.activeProviders.push('mta');
      stats.mta = this.mtaService.getStats();
    }

    return stats;
  }
}