import * as plugins from '../../plugins.js';
import * as paths from '../../paths.js';
import { Email } from '../core/classes.email.js';
import { EmailSignJob } from './classes.emailsignjob.js';
import type { UnifiedEmailServer } from '../routing/classes.unified.email.server.js';
import type { SmtpClient } from './smtpclient/smtp-client.js';
import type { ISmtpSendResult } from './smtpclient/interfaces.js';

// Configuration options for email sending
export interface IEmailSendOptions {
  maxRetries?: number;
  retryDelay?: number; // in milliseconds
  connectionTimeout?: number; // in milliseconds
  tlsOptions?: plugins.tls.ConnectionOptions;
  debugMode?: boolean;
}

// Email delivery status
export enum DeliveryStatus {
  PENDING = 'pending',
  SENDING = 'sending',
  DELIVERED = 'delivered',
  FAILED = 'failed',
  DEFERRED = 'deferred' // Temporary failure, will retry
}

// Detailed information about delivery attempts
export interface DeliveryInfo {
  status: DeliveryStatus;
  attempts: number;
  error?: Error;
  lastAttempt?: Date;
  nextAttempt?: Date;
  mxServer?: string;
  deliveryTime?: Date;
  logs: string[];
}

export class EmailSendJob {
  emailServerRef: UnifiedEmailServer;
  private email: Email;
  private mxServers: string[] = [];
  private currentMxIndex = 0;
  private options: IEmailSendOptions;
  public deliveryInfo: DeliveryInfo;

  constructor(emailServerRef: UnifiedEmailServer, emailArg: Email, options: IEmailSendOptions = {}) {
    this.email = emailArg;
    this.emailServerRef = emailServerRef;
    
    // Set default options
    this.options = {
      maxRetries: options.maxRetries || 3,
      retryDelay: options.retryDelay || 30000, // 30 seconds
      connectionTimeout: options.connectionTimeout || 60000, // 60 seconds
      tlsOptions: options.tlsOptions || {},
      debugMode: options.debugMode || false
    };
    
    // Initialize delivery info
    this.deliveryInfo = {
      status: DeliveryStatus.PENDING,
      attempts: 0,
      logs: []
    };
  }

  /**
   * Send the email to its recipients
   */
  async send(): Promise<DeliveryStatus> {
    try {
      // Check if the email is valid before attempting to send
      this.validateEmail();
      
      // Resolve MX records for the recipient domain
      await this.resolveMxRecords();
      
      // Try to send the email
      return await this.attemptDelivery();
    } catch (error) {
      this.log(`Critical error in send process: ${error.message}`);
      this.deliveryInfo.status = DeliveryStatus.FAILED;
      this.deliveryInfo.error = error;
      
      // Save failed email for potential future retry or analysis
      await this.saveFailed();
      return DeliveryStatus.FAILED;
    }
  }

  /**
   * Validate the email before sending
   */
  private validateEmail(): void {
    if (!this.email.to || this.email.to.length === 0) {
      throw new Error('No recipients specified');
    }
    
    if (!this.email.from) {
      throw new Error('No sender specified');
    }
    
    const fromDomain = this.email.getFromDomain();
    if (!fromDomain) {
      throw new Error('Invalid sender domain');
    }
  }

  /**
   * Resolve MX records for the recipient domain
   */
  private async resolveMxRecords(): Promise<void> {
    const domain = this.email.getPrimaryRecipient()?.split('@')[1];
    if (!domain) {
      throw new Error('Invalid recipient domain');
    }
    
    this.log(`Resolving MX records for domain: ${domain}`);
    try {
      const addresses = await this.resolveMx(domain);
      
      // Sort by priority (lowest number = highest priority)
      addresses.sort((a, b) => a.priority - b.priority);
      
      this.mxServers = addresses.map(mx => mx.exchange);
      this.log(`Found ${this.mxServers.length} MX servers: ${this.mxServers.join(', ')}`);
      
      if (this.mxServers.length === 0) {
        throw new Error(`No MX records found for domain: ${domain}`);
      }
    } catch (error) {
      this.log(`Failed to resolve MX records: ${error.message}`);
      throw new Error(`MX lookup failed for ${domain}: ${error.message}`);
    }
  }

  /**
   * Attempt to deliver the email with retries
   */
  private async attemptDelivery(): Promise<DeliveryStatus> {
    while (this.deliveryInfo.attempts < this.options.maxRetries) {
      this.deliveryInfo.attempts++;
      this.deliveryInfo.lastAttempt = new Date();
      this.deliveryInfo.status = DeliveryStatus.SENDING;
      
      try {
        this.log(`Delivery attempt ${this.deliveryInfo.attempts} of ${this.options.maxRetries}`);
        
        // Try each MX server in order of priority
        while (this.currentMxIndex < this.mxServers.length) {
          const currentMx = this.mxServers[this.currentMxIndex];
          this.deliveryInfo.mxServer = currentMx;
          
          try {
            this.log(`Attempting delivery to MX server: ${currentMx}`);
            await this.connectAndSend(currentMx);
            
            // If we get here, email was sent successfully
            this.deliveryInfo.status = DeliveryStatus.DELIVERED;
            this.deliveryInfo.deliveryTime = new Date();
            this.log(`Email delivered successfully to ${currentMx}`);
            
            // Record delivery for sender reputation monitoring
            this.recordDeliveryEvent('delivered');
            
            // Save successful email record
            await this.saveSuccess();
            return DeliveryStatus.DELIVERED;
          } catch (error) {
            this.log(`Failed to deliver to ${currentMx}: ${error.message}`);
            this.currentMxIndex++;
            
            // If this MX server failed, try the next one
            if (this.currentMxIndex >= this.mxServers.length) {
              throw error; // No more MX servers to try
            }
          }
        }
        
        throw new Error('All MX servers failed');
      } catch (error) {
        this.deliveryInfo.error = error;
        
        // Check if this is a permanent failure
        if (this.isPermanentFailure(error)) {
          this.log('Permanent failure detected, not retrying');
          this.deliveryInfo.status = DeliveryStatus.FAILED;
          
          // Record permanent failure for bounce management
          this.recordDeliveryEvent('bounced', true);
          
          await this.saveFailed();
          return DeliveryStatus.FAILED;
        }
        
        // This is a temporary failure
        if (this.deliveryInfo.attempts < this.options.maxRetries) {
          this.log(`Temporary failure, will retry in ${this.options.retryDelay}ms`);
          this.deliveryInfo.status = DeliveryStatus.DEFERRED;
          this.deliveryInfo.nextAttempt = new Date(Date.now() + this.options.retryDelay);
          
          // Record temporary failure for monitoring
          this.recordDeliveryEvent('deferred');
          
          // Reset MX server index for next retry
          this.currentMxIndex = 0;
          
          // Wait before retrying
          await this.delay(this.options.retryDelay);
        }
      }
    }
    
    // If we get here, all retries failed
    this.deliveryInfo.status = DeliveryStatus.FAILED;
    await this.saveFailed();
    return DeliveryStatus.FAILED;
  }

  /**
   * Connect to a specific MX server and send the email using SmtpClient
   */
  private async connectAndSend(mxServer: string): Promise<void> {
    this.log(`Connecting to ${mxServer}:25`);
    
    try {
      // Check if IP warmup is enabled and get an IP to use
      let localAddress: string | undefined = undefined;
      try {
        const fromDomain = this.email.getFromDomain();
        const bestIP = this.emailServerRef.getBestIPForSending({
          from: this.email.from,
          to: this.email.getAllRecipients(),
          domain: fromDomain,
          isTransactional: this.email.priority === 'high'
        });
        
        if (bestIP) {
          this.log(`Using warmed-up IP ${bestIP} for sending`);
          localAddress = bestIP;
          
          // Record the send for warm-up tracking
          this.emailServerRef.recordIPSend(bestIP);
        }
      } catch (error) {
        this.log(`Error selecting IP address: ${error.message}`);
      }
      
      // Get SMTP client from UnifiedEmailServer
      const smtpClient = this.emailServerRef.getSmtpClient(mxServer, 25);
      
      // Sign the email with DKIM if available
      let signedEmail = this.email;
      try {
        const fromDomain = this.email.getFromDomain();
        if (fromDomain && this.emailServerRef.hasDkimKey(fromDomain)) {
          // Convert email to RFC822 format for signing
          const emailMessage = this.email.toRFC822String();
          
          // Create sign job with proper options
          const emailSignJob = new EmailSignJob(this.emailServerRef, {
            domain: fromDomain,
            selector: 'default', // Using default selector
            headers: {}, // Headers will be extracted from emailMessage
            body: emailMessage
          });
          
          // Get the DKIM signature header
          const signatureHeader = await emailSignJob.getSignatureHeader(emailMessage);
          
          // Add the signature to the email
          if (signatureHeader) {
            // For now, we'll use the email as-is since SmtpClient will handle DKIM
            this.log(`Email ready for DKIM signing for domain: ${fromDomain}`);
          }
        }
      } catch (error) {
        this.log(`Failed to prepare DKIM: ${error.message}`);
      }
      
      // Send the email using SmtpClient
      const result: ISmtpSendResult = await smtpClient.sendMail(signedEmail);
      
      if (result.success) {
        this.log(`Email sent successfully: ${result.response}`);
        
        // Record the send for reputation monitoring
        this.recordDeliveryEvent('delivered');
      } else {
        throw new Error(result.error?.message || 'Failed to send email');
      }
    } catch (error) {
      this.log(`Failed to send email via ${mxServer}: ${error.message}`);
      throw error;
    }
  }

  /**
   * Record delivery event for monitoring
   */
  private recordDeliveryEvent(
    eventType: 'delivered' | 'bounced' | 'deferred',
    isHardBounce: boolean = false
  ): void {
    try {
      const domain = this.email.getFromDomain();
      if (domain) {
        if (eventType === 'delivered') {
          this.emailServerRef.recordDelivery(domain);
        } else if (eventType === 'bounced') {
          // Get the receiving domain for bounce recording
          let receivingDomain = null;
          const primaryRecipient = this.email.getPrimaryRecipient();
          if (primaryRecipient) {
            receivingDomain = primaryRecipient.split('@')[1];
          }
          
          if (receivingDomain) {
            this.emailServerRef.recordBounce(
              domain,
              receivingDomain,
              isHardBounce ? 'hard' : 'soft',
              this.deliveryInfo.error?.message || 'Unknown error'
            );
          }
        }
      }
    } catch (error) {
      this.log(`Failed to record delivery event: ${error.message}`);
    }
  }

  /**
   * Check if an error represents a permanent failure
   */
  private isPermanentFailure(error: Error): boolean {
    const permanentFailurePatterns = [
      'User unknown',
      'No such user',
      'Mailbox not found',
      'Invalid recipient',
      'Account disabled',
      'Account suspended',
      'Domain not found',
      'No such domain',
      'Invalid domain',
      'Relay access denied',
      'Access denied',
      'Blacklisted',
      'Blocked',
      '550', // Permanent failure SMTP code
      '551',
      '552',
      '553',
      '554'
    ];
    
    const errorMessage = error.message.toLowerCase();
    return permanentFailurePatterns.some(pattern => 
      errorMessage.includes(pattern.toLowerCase())
    );
  }

  /**
   * Resolve MX records for a domain
   */
  private resolveMx(domain: string): Promise<plugins.dns.MxRecord[]> {
    return new Promise((resolve, reject) => {
      plugins.dns.resolveMx(domain, (err, addresses) => {
        if (err) {
          reject(err);
        } else {
          resolve(addresses || []);
        }
      });
    });
  }

  /**
   * Log a message with timestamp
   */
  private log(message: string): void {
    const timestamp = new Date().toISOString();
    const logEntry = `[${timestamp}] ${message}`;
    this.deliveryInfo.logs.push(logEntry);
    
    if (this.options.debugMode) {
      console.log(`[EmailSendJob] ${logEntry}`);
    }
  }

  /**
   * Save successful email to storage
   */
  private async saveSuccess(): Promise<void> {
    try {
      // Use the existing email storage path
      const emailContent = this.email.toRFC822String();
      const fileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_success.eml`;
      const filePath = plugins.path.join(paths.sentEmailsDir, fileName);
      
      await plugins.smartfile.fs.ensureDir(paths.sentEmailsDir);
      await plugins.smartfile.memory.toFs(emailContent, filePath);
      
      // Also save delivery info
      const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_info.json`;
      const infoPath = plugins.path.join(paths.sentEmailsDir, infoFileName);
      await plugins.smartfile.memory.toFs(JSON.stringify(this.deliveryInfo, null, 2), infoPath);
      
      this.log(`Email saved to ${fileName}`);
    } catch (error) {
      this.log(`Failed to save email: ${error.message}`);
    }
  }

  /**
   * Save failed email to storage
   */
  private async saveFailed(): Promise<void> {
    try {
      // Use the existing email storage path
      const emailContent = this.email.toRFC822String();
      const fileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_failed.eml`;
      const filePath = plugins.path.join(paths.failedEmailsDir, fileName);
      
      await plugins.smartfile.fs.ensureDir(paths.failedEmailsDir);
      await plugins.smartfile.memory.toFs(emailContent, filePath);
      
      // Also save delivery info with error details
      const infoFileName = `${Date.now()}_${this.email.from}_to_${this.email.to[0]}_error.json`;
      const infoPath = plugins.path.join(paths.failedEmailsDir, infoFileName);
      await plugins.smartfile.memory.toFs(JSON.stringify(this.deliveryInfo, null, 2), infoPath);
      
      this.log(`Failed email saved to ${fileName}`);
    } catch (error) {
      this.log(`Failed to save failed email: ${error.message}`);
    }
  }

  /**
   * Delay for specified milliseconds
   */
  private delay(ms: number): Promise<void> {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}