import * as plugins from '../../plugins.js';
import * as paths from '../../paths.js';
import { EventEmitter } from 'events';
import { logger } from '../../logger.js';
import { SecurityLogger, SecurityLogLevel, SecurityEventType } from '../../security/index.js';
import { DKIMCreator } from '../security/classes.dkimcreator.js';
import { IPReputationChecker } from '../../security/classes.ipreputationchecker.js';
import { RustSecurityBridge } from '../../security/classes.rustsecuritybridge.js';
import { EmailRouter } from './classes.email.router.js';
import { Email } from '../core/classes.email.js';
import { DomainRegistry } from './classes.domain.registry.js';
import { DnsManager } from './classes.dns.manager.js';
import { BounceManager, BounceType, BounceCategory } from '../core/classes.bouncemanager.js';
import { createPooledSmtpClient } from '../delivery/smtpclient/create-client.js';
import { MultiModeDeliverySystem } from '../delivery/classes.delivery.system.js';
import { UnifiedDeliveryQueue } from '../delivery/classes.delivery.queue.js';
import { UnifiedRateLimiter } from '../delivery/classes.unified.rate.limiter.js';
import { SmtpState } from '../delivery/interfaces.js';
/**
 * Unified email server that handles all email traffic with pattern-based routing
 */
export class UnifiedEmailServer extends EventEmitter {
    dcRouter;
    options;
    emailRouter;
    domainRegistry;
    servers = [];
    stats;
    // Add components needed for sending and securing emails
    dkimCreator;
    rustBridge;
    ipReputationChecker;
    bounceManager;
    ipWarmupManager;
    senderReputationMonitor;
    deliveryQueue;
    deliverySystem;
    rateLimiter; // TODO: Implement rate limiting in SMTP server handlers
    dkimKeys = new Map(); // domain -> private key
    smtpClients = new Map(); // host:port -> client
    constructor(dcRouter, options) {
        super();
        this.dcRouter = dcRouter;
        // Set default options
        this.options = {
            ...options,
            banner: options.banner || `${options.hostname} ESMTP UnifiedEmailServer`,
            maxMessageSize: options.maxMessageSize || 10 * 1024 * 1024, // 10MB
            maxClients: options.maxClients || 100,
            maxConnections: options.maxConnections || 1000,
            connectionTimeout: options.connectionTimeout || 60000, // 1 minute
            socketTimeout: options.socketTimeout || 60000 // 1 minute
        };
        // Initialize Rust security bridge (singleton)
        this.rustBridge = RustSecurityBridge.getInstance();
        // Initialize DKIM creator with storage manager
        this.dkimCreator = new DKIMCreator(paths.keysDir, dcRouter.storageManager);
        // Initialize IP reputation checker with storage manager
        this.ipReputationChecker = IPReputationChecker.getInstance({
            enableLocalCache: true,
            enableDNSBL: true,
            enableIPInfo: true
        }, dcRouter.storageManager);
        // Initialize bounce manager with storage manager
        this.bounceManager = new BounceManager({
            maxCacheSize: 10000,
            cacheTTL: 30 * 24 * 60 * 60 * 1000, // 30 days
            storageManager: dcRouter.storageManager
        });
        // IP warmup manager and sender reputation monitor are optional
        // They will be initialized when the deliverability module is available
        this.ipWarmupManager = null;
        this.senderReputationMonitor = null;
        // Initialize domain registry
        this.domainRegistry = new DomainRegistry(options.domains, options.defaults);
        // Initialize email router with routes and storage manager
        this.emailRouter = new EmailRouter(options.routes || [], {
            storageManager: dcRouter.storageManager,
            persistChanges: true
        });
        // Initialize rate limiter
        this.rateLimiter = new UnifiedRateLimiter(options.rateLimits || {
            global: {
                maxConnectionsPerIP: 10,
                maxMessagesPerMinute: 100,
                maxRecipientsPerMessage: 50,
                maxErrorsPerIP: 10,
                maxAuthFailuresPerIP: 5,
                blockDuration: 300000 // 5 minutes
            }
        });
        // Initialize delivery components
        const queueOptions = {
            storageType: 'memory', // Default to memory storage
            maxRetries: 3,
            baseRetryDelay: 300000, // 5 minutes
            maxRetryDelay: 3600000 // 1 hour
        };
        this.deliveryQueue = new UnifiedDeliveryQueue(queueOptions);
        const deliveryOptions = {
            globalRateLimit: 100, // Default to 100 emails per minute
            concurrentDeliveries: 10,
            processBounces: true,
            bounceHandler: {
                processSmtpFailure: this.processSmtpFailure.bind(this)
            },
            onDeliverySuccess: async (item, _result) => {
                // Record delivery success event for reputation monitoring
                const email = item.processingResult;
                const senderDomain = email.from.split('@')[1];
                if (senderDomain) {
                    this.recordReputationEvent(senderDomain, {
                        type: 'delivered',
                        count: email.to.length
                    });
                }
            }
        };
        this.deliverySystem = new MultiModeDeliverySystem(this.deliveryQueue, deliveryOptions, this);
        // Initialize statistics
        this.stats = {
            startTime: new Date(),
            connections: {
                current: 0,
                total: 0
            },
            messages: {
                processed: 0,
                delivered: 0,
                failed: 0
            },
            processingTime: {
                avg: 0,
                max: 0,
                min: 0
            }
        };
        // We'll create the SMTP servers during the start() method
    }
    /**
     * Get or create an SMTP client for the given host and port
     * Uses connection pooling for efficiency
     */
    getSmtpClient(host, port = 25) {
        const clientKey = `${host}:${port}`;
        // Check if we already have a client for this destination
        let client = this.smtpClients.get(clientKey);
        if (!client) {
            // Create a new pooled SMTP client
            client = createPooledSmtpClient({
                host,
                port,
                secure: port === 465,
                connectionTimeout: this.options.outbound?.connectionTimeout || 30000,
                socketTimeout: this.options.outbound?.socketTimeout || 120000,
                maxConnections: this.options.outbound?.maxConnections || 10,
                maxMessages: 1000, // Messages per connection before reconnect
                pool: true,
                debug: false
            });
            this.smtpClients.set(clientKey, client);
            logger.log('info', `Created new SMTP client pool for ${clientKey}`);
        }
        return client;
    }
    /**
     * Start the unified email server
     */
    async start() {
        logger.log('info', `Starting UnifiedEmailServer on ports: ${this.options.ports.join(', ')}`);
        try {
            // Initialize the delivery queue
            await this.deliveryQueue.initialize();
            logger.log('info', 'Email delivery queue initialized');
            // Start the delivery system
            await this.deliverySystem.start();
            logger.log('info', 'Email delivery system started');
            // Start Rust security bridge — required for all security operations
            const bridgeOk = await this.rustBridge.start();
            if (!bridgeOk) {
                throw new Error('Rust security bridge failed to start. The mailer-bin binary is required. Run "pnpm build" to compile it.');
            }
            logger.log('info', 'Rust security bridge started — Rust is the primary security backend');
            // Set up DKIM for all domains
            await this.setupDkimForDomains();
            logger.log('info', 'DKIM configuration completed for all domains');
            // Create DNS manager and ensure all DNS records are created
            const dnsManager = new DnsManager(this.dcRouter);
            await dnsManager.ensureDnsRecords(this.domainRegistry.getAllConfigs(), this.dkimCreator);
            logger.log('info', 'DNS records ensured for all configured domains');
            // Apply per-domain rate limits
            this.applyDomainRateLimits();
            logger.log('info', 'Per-domain rate limits configured');
            // Check and rotate DKIM keys if needed
            await this.checkAndRotateDkimKeys();
            logger.log('info', 'DKIM key rotation check completed');
            // Ensure we have the necessary TLS options
            const hasTlsConfig = this.options.tls?.keyPath && this.options.tls?.certPath;
            // Prepare the certificate and key if available
            let tlsCertPem;
            let tlsKeyPem;
            if (hasTlsConfig) {
                try {
                    tlsKeyPem = plugins.fs.readFileSync(this.options.tls.keyPath, 'utf8');
                    tlsCertPem = plugins.fs.readFileSync(this.options.tls.certPath, 'utf8');
                    logger.log('info', 'TLS certificates loaded successfully');
                }
                catch (error) {
                    logger.log('warn', `Failed to load TLS certificates: ${error.message}`);
                }
            }
            // --- Start Rust SMTP server ---
            // Register event handlers for email reception and auth
            this.rustBridge.onEmailReceived(async (data) => {
                try {
                    await this.handleRustEmailReceived(data);
                }
                catch (err) {
                    logger.log('error', `Error handling email from Rust SMTP: ${err.message}`);
                    // Send rejection back to Rust
                    await this.rustBridge.sendEmailProcessingResult({
                        correlationId: data.correlationId,
                        accepted: false,
                        smtpCode: 451,
                        smtpMessage: 'Internal processing error',
                    });
                }
            });
            this.rustBridge.onAuthRequest(async (data) => {
                try {
                    await this.handleRustAuthRequest(data);
                }
                catch (err) {
                    logger.log('error', `Error handling auth from Rust SMTP: ${err.message}`);
                    await this.rustBridge.sendAuthResult({
                        correlationId: data.correlationId,
                        success: false,
                        message: 'Internal auth error',
                    });
                }
            });
            // Determine which ports need STARTTLS and which need implicit TLS
            const smtpPorts = this.options.ports.filter(p => p !== 465);
            const securePort = this.options.ports.find(p => p === 465);
            const started = await this.rustBridge.startSmtpServer({
                hostname: this.options.hostname,
                ports: smtpPorts,
                securePort: securePort,
                tlsCertPem,
                tlsKeyPem,
                maxMessageSize: this.options.maxMessageSize || 10 * 1024 * 1024,
                maxConnections: this.options.maxConnections || this.options.maxClients || 100,
                maxRecipients: 100,
                connectionTimeoutSecs: this.options.connectionTimeout ? Math.floor(this.options.connectionTimeout / 1000) : 30,
                dataTimeoutSecs: 60,
                authEnabled: !!this.options.auth?.required || !!(this.options.auth?.users?.length),
                maxAuthFailures: 3,
                socketTimeoutSecs: this.options.socketTimeout ? Math.floor(this.options.socketTimeout / 1000) : 300,
                processingTimeoutSecs: 30,
                rateLimits: this.options.rateLimits ? {
                    maxConnectionsPerIp: this.options.rateLimits.global?.maxConnectionsPerIP || 50,
                    maxMessagesPerSender: this.options.rateLimits.global?.maxMessagesPerMinute || 100,
                    maxAuthFailuresPerIp: this.options.rateLimits.global?.maxAuthFailuresPerIP || 5,
                    windowSecs: 60,
                } : undefined,
            });
            if (!started) {
                throw new Error('Failed to start Rust SMTP server');
            }
            logger.log('info', `Rust SMTP server listening on ports: ${smtpPorts.join(', ')}${securePort ? ` + ${securePort} (TLS)` : ''}`);
            logger.log('info', 'UnifiedEmailServer started successfully');
            this.emit('started');
        }
        catch (error) {
            logger.log('error', `Failed to start UnifiedEmailServer: ${error.message}`);
            throw error;
        }
    }
    /**
     * Stop the unified email server
     */
    async stop() {
        logger.log('info', 'Stopping UnifiedEmailServer');
        try {
            // Stop the Rust SMTP server first
            try {
                await this.rustBridge.stopSmtpServer();
                logger.log('info', 'Rust SMTP server stopped');
            }
            catch (err) {
                logger.log('warn', `Error stopping Rust SMTP server: ${err.message}`);
            }
            // Clear the servers array - servers will be garbage collected
            this.servers = [];
            // Stop Rust security bridge
            await this.rustBridge.stop();
            // Stop the delivery system
            if (this.deliverySystem) {
                await this.deliverySystem.stop();
                logger.log('info', 'Email delivery system stopped');
            }
            // Shut down the delivery queue
            if (this.deliveryQueue) {
                await this.deliveryQueue.shutdown();
                logger.log('info', 'Email delivery queue shut down');
            }
            // Close all SMTP client connections
            for (const [clientKey, client] of this.smtpClients) {
                try {
                    await client.close();
                    logger.log('info', `Closed SMTP client pool for ${clientKey}`);
                }
                catch (error) {
                    logger.log('warn', `Error closing SMTP client for ${clientKey}: ${error.message}`);
                }
            }
            this.smtpClients.clear();
            logger.log('info', 'UnifiedEmailServer stopped successfully');
            this.emit('stopped');
        }
        catch (error) {
            logger.log('error', `Error stopping UnifiedEmailServer: ${error.message}`);
            throw error;
        }
    }
    // -----------------------------------------------------------------------
    // Rust SMTP server event handlers
    // -----------------------------------------------------------------------
    /**
     * Handle an emailReceived event from the Rust SMTP server.
     * Decodes the email data, processes it through the routing system,
     * and sends back the result via the correlation-ID callback.
     */
    async handleRustEmailReceived(data) {
        const { correlationId, mailFrom, rcptTo, remoteAddr, clientHostname, secure, authenticatedUser } = data;
        logger.log('info', `Rust SMTP received email from=${mailFrom} to=${rcptTo.join(',')} remote=${remoteAddr}`);
        try {
            // Decode the email data
            let rawMessageBuffer;
            if (data.data.type === 'inline' && data.data.base64) {
                rawMessageBuffer = Buffer.from(data.data.base64, 'base64');
            }
            else if (data.data.type === 'file' && data.data.path) {
                rawMessageBuffer = plugins.fs.readFileSync(data.data.path);
                // Clean up temp file
                try {
                    plugins.fs.unlinkSync(data.data.path);
                }
                catch {
                    // Ignore cleanup errors
                }
            }
            else {
                throw new Error('Invalid email data transport');
            }
            // Build a session-like object for processEmailByMode
            const session = {
                id: data.sessionId || 'rust-' + Math.random().toString(36).substring(2),
                state: SmtpState.FINISHED,
                mailFrom: mailFrom,
                rcptTo: rcptTo,
                emailData: rawMessageBuffer.toString('utf8'),
                useTLS: secure,
                connectionEnded: false,
                remoteAddress: remoteAddr,
                clientHostname: clientHostname || '',
                secure: secure,
                authenticated: !!authenticatedUser,
                envelope: {
                    mailFrom: { address: mailFrom, args: {} },
                    rcptTo: rcptTo.map(addr => ({ address: addr, args: {} })),
                },
            };
            if (authenticatedUser) {
                session.user = { username: authenticatedUser };
            }
            // Attach pre-computed security results from Rust in-process pipeline
            if (data.securityResults) {
                session._precomputedSecurityResults = data.securityResults;
            }
            // Process the email through the routing system
            await this.processEmailByMode(rawMessageBuffer, session);
            // Send acceptance back to Rust
            await this.rustBridge.sendEmailProcessingResult({
                correlationId,
                accepted: true,
                smtpCode: 250,
                smtpMessage: '2.0.0 Message accepted for delivery',
            });
        }
        catch (err) {
            logger.log('error', `Failed to process email from Rust SMTP: ${err.message}`);
            await this.rustBridge.sendEmailProcessingResult({
                correlationId,
                accepted: false,
                smtpCode: 550,
                smtpMessage: `5.0.0 Processing failed: ${err.message}`,
            });
        }
    }
    /**
     * Handle an authRequest event from the Rust SMTP server.
     * Validates credentials and sends back the result.
     */
    async handleRustAuthRequest(data) {
        const { correlationId, username, password, remoteAddr } = data;
        logger.log('info', `Rust SMTP auth request for user=${username} from=${remoteAddr}`);
        // Check against configured users
        const users = this.options.auth?.users || [];
        const matched = users.find(u => u.username === username && u.password === password);
        if (matched) {
            await this.rustBridge.sendAuthResult({
                correlationId,
                success: true,
            });
        }
        else {
            logger.log('warn', `Auth failed for user=${username} from=${remoteAddr}`);
            await this.rustBridge.sendAuthResult({
                correlationId,
                success: false,
                message: 'Invalid credentials',
            });
        }
    }
    /**
     * Verify inbound email security (DKIM/SPF/DMARC) using pre-computed Rust results
     * or falling back to IPC call if no pre-computed results are available.
     */
    async verifyInboundSecurity(email, session) {
        try {
            // Check for pre-computed results from Rust in-process security pipeline
            const precomputed = session._precomputedSecurityResults;
            let result;
            if (precomputed) {
                logger.log('info', 'Using pre-computed security results from Rust in-process pipeline');
                result = precomputed;
            }
            else {
                // Fallback: IPC round-trip to Rust (for backward compat / handleSocket mode)
                const rawMessage = session.emailData || email.toRFC822String();
                result = await this.rustBridge.verifyEmail({
                    rawMessage,
                    ip: session.remoteAddress,
                    heloDomain: session.clientHostname || '',
                    hostname: this.options.hostname,
                    mailFrom: session.envelope?.mailFrom?.address || session.mailFrom || '',
                });
            }
            // Apply DKIM result headers
            if (result.dkim && result.dkim.length > 0) {
                const dkimSummary = result.dkim
                    .map((d) => `${d.status}${d.domain ? ` (${d.domain})` : ''}`)
                    .join(', ');
                email.addHeader('X-DKIM-Result', dkimSummary);
            }
            // Apply SPF result header
            if (result.spf) {
                email.addHeader('Received-SPF', `${result.spf.result} (domain: ${result.spf.domain}, ip: ${result.spf.ip})`);
                // Mark as spam on SPF hard fail
                if (result.spf.result === 'fail') {
                    email.mightBeSpam = true;
                    logger.log('warn', `SPF fail for ${session.remoteAddress} — marking as potential spam`);
                }
            }
            // Apply DMARC result header and policy
            if (result.dmarc) {
                email.addHeader('X-DMARC-Result', `${result.dmarc.action} (policy=${result.dmarc.policy}, dkim=${result.dmarc.dkim_result}, spf=${result.dmarc.spf_result})`);
                if (result.dmarc.action === 'reject') {
                    email.mightBeSpam = true;
                    logger.log('warn', `DMARC reject for domain ${result.dmarc.domain} — marking as spam`);
                }
                else if (result.dmarc.action === 'quarantine') {
                    email.mightBeSpam = true;
                    logger.log('info', `DMARC quarantine for domain ${result.dmarc.domain} — marking as potential spam`);
                }
            }
            // Apply content scan results (from pre-computed pipeline)
            if (result.contentScan) {
                const scan = result.contentScan;
                if (scan.threatScore > 0) {
                    email.addHeader('X-Spam-Score', String(scan.threatScore));
                    if (scan.threatType) {
                        email.addHeader('X-Spam-Type', scan.threatType);
                    }
                    if (scan.threatScore >= 50) {
                        email.mightBeSpam = true;
                        logger.log('warn', `Content scan threat score ${scan.threatScore} (${scan.threatType}) — marking as potential spam`);
                    }
                }
            }
            // Apply IP reputation results (from pre-computed pipeline)
            if (result.ipReputation) {
                const rep = result.ipReputation;
                email.addHeader('X-IP-Reputation-Score', String(rep.score));
                if (rep.is_spam) {
                    email.mightBeSpam = true;
                    logger.log('warn', `IP ${rep.ip} flagged by reputation check (score=${rep.score}) — marking as potential spam`);
                }
            }
            logger.log('info', `Inbound security verified for email from ${session.remoteAddress}: DKIM=${result.dkim?.[0]?.status ?? 'none'}, SPF=${result.spf?.result ?? 'none'}, DMARC=${result.dmarc?.action ?? 'none'}`);
        }
        catch (err) {
            logger.log('warn', `Inbound security verification failed: ${err.message} — accepting email`);
        }
    }
    /**
     * Process email based on routing rules
     */
    async processEmailByMode(emailData, session) {
        // Convert Buffer to Email if needed
        let email;
        if (Buffer.isBuffer(emailData)) {
            // Parse the email data buffer into an Email object
            try {
                const parsed = await plugins.mailparser.simpleParser(emailData);
                email = new Email({
                    from: parsed.from?.value[0]?.address || session.envelope.mailFrom.address,
                    to: session.envelope.rcptTo[0]?.address || '',
                    subject: parsed.subject || '',
                    text: parsed.text || '',
                    html: parsed.html || undefined,
                    attachments: parsed.attachments?.map(att => ({
                        filename: att.filename || '',
                        content: att.content,
                        contentType: att.contentType
                    })) || []
                });
            }
            catch (error) {
                logger.log('error', `Error parsing email data: ${error.message}`);
                throw new Error(`Error parsing email data: ${error.message}`);
            }
        }
        else {
            email = emailData;
        }
        // Run inbound security verification (DKIM/SPF/DMARC) via Rust bridge
        if (session.remoteAddress && session.remoteAddress !== '127.0.0.1') {
            await this.verifyInboundSecurity(email, session);
        }
        // First check if this is a bounce notification email
        // Look for common bounce notification subject patterns
        const subject = email.subject || '';
        const isBounceLike = /mail delivery|delivery (failed|status|notification)|failure notice|returned mail|undeliverable|delivery problem/i.test(subject);
        if (isBounceLike) {
            logger.log('info', `Email subject matches bounce notification pattern: "${subject}"`);
            // Try to process as a bounce
            const isBounce = await this.processBounceNotification(email);
            if (isBounce) {
                logger.log('info', 'Successfully processed as bounce notification, skipping regular processing');
                return email;
            }
            logger.log('info', 'Not a valid bounce notification, continuing with regular processing');
        }
        // Find matching route
        const context = { email, session };
        const route = await this.emailRouter.evaluateRoutes(context);
        if (!route) {
            // No matching route - reject
            throw new Error('No matching route for email');
        }
        // Store matched route in session
        session.matchedRoute = route;
        // Execute action based on route
        await this.executeAction(route.action, email, context);
        // Return the processed email
        return email;
    }
    /**
     * Execute action based on route configuration
     */
    async executeAction(action, email, context) {
        switch (action.type) {
            case 'forward':
                await this.handleForwardAction(action, email, context);
                break;
            case 'process':
                await this.handleProcessAction(action, email, context);
                break;
            case 'deliver':
                await this.handleDeliverAction(action, email, context);
                break;
            case 'reject':
                await this.handleRejectAction(action, email, context);
                break;
            default:
                throw new Error(`Unknown action type: ${action.type}`);
        }
    }
    /**
     * Handle forward action
     */
    async handleForwardAction(_action, email, context) {
        if (!_action.forward) {
            throw new Error('Forward action requires forward configuration');
        }
        const { host, port = 25, auth, addHeaders } = _action.forward;
        logger.log('info', `Forwarding email to ${host}:${port}`);
        // Add forwarding headers
        if (addHeaders) {
            for (const [key, value] of Object.entries(addHeaders)) {
                email.headers[key] = value;
            }
        }
        // Add standard forwarding headers
        email.headers['X-Forwarded-For'] = context.session.remoteAddress || 'unknown';
        email.headers['X-Forwarded-To'] = email.to.join(', ');
        email.headers['X-Forwarded-Date'] = new Date().toISOString();
        // Get SMTP client
        const client = this.getSmtpClient(host, port);
        try {
            // Send email
            await client.sendMail(email);
            logger.log('info', `Successfully forwarded email to ${host}:${port}`);
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.INFO,
                type: SecurityEventType.EMAIL_FORWARDING,
                message: 'Email forwarded successfully',
                ipAddress: context.session.remoteAddress,
                details: {
                    sessionId: context.session.id,
                    routeName: context.session.matchedRoute?.name,
                    targetHost: host,
                    targetPort: port,
                    recipients: email.to
                },
                success: true
            });
        }
        catch (error) {
            logger.log('error', `Failed to forward email: ${error.message}`);
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.ERROR,
                type: SecurityEventType.EMAIL_FORWARDING,
                message: 'Email forwarding failed',
                ipAddress: context.session.remoteAddress,
                details: {
                    sessionId: context.session.id,
                    routeName: context.session.matchedRoute?.name,
                    targetHost: host,
                    targetPort: port,
                    error: error.message
                },
                success: false
            });
            // Handle as bounce
            for (const recipient of email.getAllRecipients()) {
                await this.bounceManager.processSmtpFailure(recipient, error.message, {
                    sender: email.from,
                    originalEmailId: email.headers['Message-ID']
                });
            }
            throw error;
        }
    }
    /**
     * Handle process action
     */
    async handleProcessAction(action, email, context) {
        logger.log('info', `Processing email with action options`);
        // Apply scanning if requested
        if (action.process?.scan) {
            // Use existing content scanner
            // Note: ContentScanner integration would go here
            logger.log('info', 'Content scanning requested');
        }
        // Note: DKIM signing will be applied at delivery time to ensure signature validity
        // Queue for delivery
        const queue = action.process?.queue || 'normal';
        await this.deliveryQueue.enqueue(email, 'process', context.session.matchedRoute);
        logger.log('info', `Email queued for delivery in ${queue} queue`);
    }
    /**
     * Handle deliver action
     */
    async handleDeliverAction(_action, email, context) {
        logger.log('info', `Delivering email locally`);
        // Queue for local delivery
        await this.deliveryQueue.enqueue(email, 'mta', context.session.matchedRoute);
        logger.log('info', 'Email queued for local delivery');
    }
    /**
     * Handle reject action
     */
    async handleRejectAction(action, email, context) {
        const code = action.reject?.code || 550;
        const message = action.reject?.message || 'Message rejected';
        logger.log('info', `Rejecting email with code ${code}: ${message}`);
        SecurityLogger.getInstance().logEvent({
            level: SecurityLogLevel.WARN,
            type: SecurityEventType.EMAIL_PROCESSING,
            message: 'Email rejected by routing rule',
            ipAddress: context.session.remoteAddress,
            details: {
                sessionId: context.session.id,
                routeName: context.session.matchedRoute?.name,
                rejectCode: code,
                rejectMessage: message,
                from: email.from,
                to: email.to
            },
            success: false
        });
        // Throw error with SMTP code and message
        const error = new Error(message);
        error.responseCode = code;
        throw error;
    }
    /**
     * Handle email in MTA mode (programmatic processing)
     */
    async _handleMtaMode(email, session) {
        logger.log('info', `Handling email in MTA mode for session ${session.id}`);
        try {
            // Apply MTA rule options if provided
            if (session.matchedRoute?.action.options?.mtaOptions) {
                const options = session.matchedRoute.action.options.mtaOptions;
                // Apply DKIM signing if enabled
                if (options.dkimSign && options.dkimOptions) {
                    const dkimDomain = options.dkimOptions.domainName;
                    const dkimSelector = options.dkimOptions.keySelector || 'mta';
                    logger.log('info', `Signing email with DKIM for domain ${dkimDomain}`);
                    await this.handleDkimSigning(email, dkimDomain, dkimSelector);
                }
            }
            // Get email content for logging/processing
            const subject = email.subject;
            const recipients = email.getAllRecipients().join(', ');
            logger.log('info', `Email processed by MTA: ${subject} to ${recipients}`);
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.INFO,
                type: SecurityEventType.EMAIL_PROCESSING,
                message: 'Email processed by MTA',
                ipAddress: session.remoteAddress,
                details: {
                    sessionId: session.id,
                    ruleName: session.matchedRoute?.name || 'default',
                    subject,
                    recipients
                },
                success: true
            });
        }
        catch (error) {
            logger.log('error', `Failed to process email in MTA mode: ${error.message}`);
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.ERROR,
                type: SecurityEventType.EMAIL_PROCESSING,
                message: 'MTA processing failed',
                ipAddress: session.remoteAddress,
                details: {
                    sessionId: session.id,
                    ruleName: session.matchedRoute?.name || 'default',
                    error: error.message
                },
                success: false
            });
            throw error;
        }
    }
    /**
     * Handle email in process mode (store-and-forward with scanning)
     */
    async _handleProcessMode(email, session) {
        logger.log('info', `Handling email in process mode for session ${session.id}`);
        try {
            const route = session.matchedRoute;
            // Apply content scanning if enabled
            if (route?.action.options?.contentScanning && route.action.options.scanners && route.action.options.scanners.length > 0) {
                logger.log('info', 'Performing content scanning');
                // Apply each scanner
                for (const scanner of route.action.options.scanners) {
                    switch (scanner.type) {
                        case 'spam':
                            logger.log('info', 'Scanning for spam content');
                            // Implement spam scanning
                            break;
                        case 'virus':
                            logger.log('info', 'Scanning for virus content');
                            // Implement virus scanning
                            break;
                        case 'attachment':
                            logger.log('info', 'Scanning attachments');
                            // Check for blocked extensions
                            if (scanner.blockedExtensions && scanner.blockedExtensions.length > 0) {
                                for (const attachment of email.attachments) {
                                    const ext = this.getFileExtension(attachment.filename);
                                    if (scanner.blockedExtensions.includes(ext)) {
                                        if (scanner.action === 'reject') {
                                            throw new Error(`Blocked attachment type: ${ext}`);
                                        }
                                        else { // tag
                                            email.addHeader('X-Attachment-Warning', `Potentially unsafe attachment: ${attachment.filename}`);
                                        }
                                    }
                                }
                            }
                            break;
                    }
                }
            }
            // Apply transformations if defined
            if (route?.action.options?.transformations && route.action.options.transformations.length > 0) {
                logger.log('info', 'Applying email transformations');
                for (const transform of route.action.options.transformations) {
                    switch (transform.type) {
                        case 'addHeader':
                            if (transform.header && transform.value) {
                                email.addHeader(transform.header, transform.value);
                            }
                            break;
                    }
                }
            }
            logger.log('info', `Email successfully processed in store-and-forward mode`);
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.INFO,
                type: SecurityEventType.EMAIL_PROCESSING,
                message: 'Email processed and queued',
                ipAddress: session.remoteAddress,
                details: {
                    sessionId: session.id,
                    ruleName: route?.name || 'default',
                    contentScanning: route?.action.options?.contentScanning || false,
                    subject: email.subject
                },
                success: true
            });
        }
        catch (error) {
            logger.log('error', `Failed to process email: ${error.message}`);
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.ERROR,
                type: SecurityEventType.EMAIL_PROCESSING,
                message: 'Email processing failed',
                ipAddress: session.remoteAddress,
                details: {
                    sessionId: session.id,
                    ruleName: session.matchedRoute?.name || 'default',
                    error: error.message
                },
                success: false
            });
            throw error;
        }
    }
    /**
     * Get file extension from filename
     */
    getFileExtension(filename) {
        return filename.substring(filename.lastIndexOf('.')).toLowerCase();
    }
    /**
     * Set up DKIM configuration for all domains
     */
    async setupDkimForDomains() {
        const domainConfigs = this.domainRegistry.getAllConfigs();
        if (domainConfigs.length === 0) {
            logger.log('warn', 'No domains configured for DKIM');
            return;
        }
        for (const domainConfig of domainConfigs) {
            const domain = domainConfig.domain;
            const selector = domainConfig.dkim?.selector || 'default';
            try {
                // Check if DKIM keys already exist for this domain
                let keyPair;
                try {
                    // Try to read existing keys
                    keyPair = await this.dkimCreator.readDKIMKeys(domain);
                    logger.log('info', `Using existing DKIM keys for domain: ${domain}`);
                }
                catch (error) {
                    // Generate new keys if they don't exist
                    keyPair = await this.dkimCreator.createDKIMKeys();
                    // Store them for future use
                    await this.dkimCreator.createAndStoreDKIMKeys(domain);
                    logger.log('info', `Generated new DKIM keys for domain: ${domain}`);
                }
                // Store the private key for signing
                this.dkimKeys.set(domain, keyPair.privateKey);
                // DNS record creation is now handled by DnsManager
                logger.log('info', `DKIM keys loaded for domain: ${domain} with selector: ${selector}`);
            }
            catch (error) {
                logger.log('error', `Failed to set up DKIM for domain ${domain}: ${error.message}`);
            }
        }
    }
    /**
     * Apply per-domain rate limits from domain configurations
     */
    applyDomainRateLimits() {
        const domainConfigs = this.domainRegistry.getAllConfigs();
        for (const domainConfig of domainConfigs) {
            if (domainConfig.rateLimits) {
                const domain = domainConfig.domain;
                const rateLimitConfig = {};
                // Convert domain-specific rate limits to the format expected by UnifiedRateLimiter
                if (domainConfig.rateLimits.outbound) {
                    if (domainConfig.rateLimits.outbound.messagesPerMinute) {
                        rateLimitConfig.maxMessagesPerMinute = domainConfig.rateLimits.outbound.messagesPerMinute;
                    }
                    // Note: messagesPerHour and messagesPerDay would need additional implementation in rate limiter
                }
                if (domainConfig.rateLimits.inbound) {
                    if (domainConfig.rateLimits.inbound.messagesPerMinute) {
                        rateLimitConfig.maxMessagesPerMinute = domainConfig.rateLimits.inbound.messagesPerMinute;
                    }
                    if (domainConfig.rateLimits.inbound.connectionsPerIp) {
                        rateLimitConfig.maxConnectionsPerIP = domainConfig.rateLimits.inbound.connectionsPerIp;
                    }
                    if (domainConfig.rateLimits.inbound.recipientsPerMessage) {
                        rateLimitConfig.maxRecipientsPerMessage = domainConfig.rateLimits.inbound.recipientsPerMessage;
                    }
                }
                // Apply the rate limits if we have any
                if (Object.keys(rateLimitConfig).length > 0) {
                    this.rateLimiter.applyDomainLimits(domain, rateLimitConfig);
                    logger.log('info', `Applied rate limits for domain ${domain}:`, rateLimitConfig);
                }
            }
        }
    }
    /**
     * Check and rotate DKIM keys if needed
     */
    async checkAndRotateDkimKeys() {
        const domainConfigs = this.domainRegistry.getAllConfigs();
        for (const domainConfig of domainConfigs) {
            const domain = domainConfig.domain;
            const selector = domainConfig.dkim?.selector || 'default';
            const rotateKeys = domainConfig.dkim?.rotateKeys || false;
            const rotationInterval = domainConfig.dkim?.rotationInterval || 90;
            const keySize = domainConfig.dkim?.keySize || 2048;
            if (!rotateKeys) {
                logger.log('debug', `DKIM key rotation disabled for ${domain}`);
                continue;
            }
            try {
                // Check if keys need rotation
                const needsRotation = await this.dkimCreator.needsRotation(domain, selector, rotationInterval);
                if (needsRotation) {
                    logger.log('info', `DKIM keys need rotation for ${domain} (selector: ${selector})`);
                    // Rotate the keys
                    const newSelector = await this.dkimCreator.rotateDkimKeys(domain, selector, keySize);
                    // Update the domain config with new selector
                    domainConfig.dkim = {
                        ...domainConfig.dkim,
                        selector: newSelector
                    };
                    // Re-register DNS handler for new selector if internal-dns mode
                    if (domainConfig.dnsMode === 'internal-dns' && this.dcRouter.dnsServer) {
                        // Get new public key
                        const keyPair = await this.dkimCreator.readDKIMKeysForSelector(domain, newSelector);
                        const publicKeyBase64 = keyPair.publicKey
                            .replace(/-----BEGIN PUBLIC KEY-----/g, '')
                            .replace(/-----END PUBLIC KEY-----/g, '')
                            .replace(/\s/g, '');
                        const ttl = domainConfig.dns?.internal?.ttl || 3600;
                        // Register new selector
                        this.dcRouter.dnsServer.registerHandler(`${newSelector}._domainkey.${domain}`, ['TXT'], () => ({
                            name: `${newSelector}._domainkey.${domain}`,
                            type: 'TXT',
                            class: 'IN',
                            ttl: ttl,
                            data: `v=DKIM1; k=rsa; p=${publicKeyBase64}`
                        }));
                        logger.log('info', `DKIM DNS handler registered for new selector: ${newSelector}._domainkey.${domain}`);
                        // Store the updated public key in storage
                        await this.dcRouter.storageManager.set(`/email/dkim/${domain}/public.key`, keyPair.publicKey);
                    }
                    // Clean up old keys after grace period (async, don't wait)
                    this.dkimCreator.cleanupOldKeys(domain, 30).catch(error => {
                        logger.log('warn', `Failed to cleanup old DKIM keys for ${domain}: ${error.message}`);
                    });
                }
                else {
                    logger.log('debug', `DKIM keys for ${domain} are up to date`);
                }
            }
            catch (error) {
                logger.log('error', `Failed to check/rotate DKIM keys for ${domain}: ${error.message}`);
            }
        }
    }
    /**
     * Generate SmartProxy routes for email ports
     */
    generateProxyRoutes(portMapping) {
        const routes = [];
        const defaultPortMapping = {
            25: 10025,
            587: 10587,
            465: 10465
        };
        const actualPortMapping = portMapping || defaultPortMapping;
        // Generate routes for each configured port
        for (const externalPort of this.options.ports) {
            const internalPort = actualPortMapping[externalPort] || externalPort + 10000;
            let routeName = 'email-route';
            let tlsMode = 'passthrough';
            // Configure based on port
            switch (externalPort) {
                case 25:
                    routeName = 'smtp-route';
                    tlsMode = 'passthrough'; // STARTTLS
                    break;
                case 587:
                    routeName = 'submission-route';
                    tlsMode = 'passthrough'; // STARTTLS
                    break;
                case 465:
                    routeName = 'smtps-route';
                    tlsMode = 'terminate'; // Implicit TLS
                    break;
                default:
                    routeName = `email-port-${externalPort}-route`;
            }
            routes.push({
                name: routeName,
                match: {
                    ports: [externalPort]
                },
                action: {
                    type: 'forward',
                    target: {
                        host: 'localhost',
                        port: internalPort
                    },
                    tls: {
                        mode: tlsMode
                    }
                }
            });
        }
        return routes;
    }
    /**
     * Update server configuration
     */
    updateOptions(options) {
        // Stop the server if changing ports
        const portsChanged = options.ports &&
            (!this.options.ports ||
                JSON.stringify(options.ports) !== JSON.stringify(this.options.ports));
        if (portsChanged) {
            this.stop().then(() => {
                this.options = { ...this.options, ...options };
                this.start();
            });
        }
        else {
            // Update options without restart
            this.options = { ...this.options, ...options };
            // Update domain registry if domains changed
            if (options.domains) {
                this.domainRegistry = new DomainRegistry(options.domains, options.defaults || this.options.defaults);
            }
            // Update email router if routes changed
            if (options.routes) {
                this.emailRouter.updateRoutes(options.routes);
            }
        }
    }
    /**
     * Update email routes
     */
    updateEmailRoutes(routes) {
        this.options.routes = routes;
        this.emailRouter.updateRoutes(routes);
    }
    /**
     * Get server statistics
     */
    getStats() {
        return { ...this.stats };
    }
    /**
     * Get domain registry
     */
    getDomainRegistry() {
        return this.domainRegistry;
    }
    /**
     * Update email routes dynamically
     */
    updateRoutes(routes) {
        this.emailRouter.setRoutes(routes);
        logger.log('info', `Updated email routes with ${routes.length} routes`);
    }
    /**
     * Send an email through the delivery system
     * @param email The email to send
     * @param mode The processing mode to use
     * @param rule Optional rule to apply
     * @param options Optional sending options
     * @returns The ID of the queued email
     */
    async sendEmail(email, mode = 'mta', route, options) {
        logger.log('info', `Sending email: ${email.subject} to ${email.to.join(', ')}`);
        try {
            // Validate the email
            if (!email.from) {
                throw new Error('Email must have a sender address');
            }
            if (!email.to || email.to.length === 0) {
                throw new Error('Email must have at least one recipient');
            }
            // Check if any recipients are on the suppression list (unless explicitly skipped)
            if (!options?.skipSuppressionCheck) {
                const suppressedRecipients = email.to.filter(recipient => this.isEmailSuppressed(recipient));
                if (suppressedRecipients.length > 0) {
                    // Filter out suppressed recipients
                    const originalCount = email.to.length;
                    const suppressed = suppressedRecipients.map(recipient => {
                        const info = this.getSuppressionInfo(recipient);
                        return {
                            email: recipient,
                            reason: info?.reason || 'Unknown',
                            until: info?.expiresAt ? new Date(info.expiresAt).toISOString() : 'permanent'
                        };
                    });
                    logger.log('warn', `Filtering out ${suppressedRecipients.length} suppressed recipient(s)`, { suppressed });
                    // If all recipients are suppressed, throw an error
                    if (suppressedRecipients.length === originalCount) {
                        throw new Error('All recipients are on the suppression list');
                    }
                    // Filter the recipients list to only include non-suppressed addresses
                    email.to = email.to.filter(recipient => !this.isEmailSuppressed(recipient));
                }
            }
            // IP warmup handling
            let ipAddress = options?.ipAddress;
            // If no specific IP was provided, use IP warmup manager to find the best IP
            if (!ipAddress) {
                const domain = email.from.split('@')[1];
                ipAddress = this.getBestIPForSending({
                    from: email.from,
                    to: email.to,
                    domain,
                    isTransactional: options?.isTransactional
                });
                if (ipAddress) {
                    logger.log('info', `Selected IP ${ipAddress} for sending based on warmup status`);
                }
            }
            // If an IP is provided or selected by warmup manager, check its capacity
            if (ipAddress) {
                // Check if the IP can send more today
                if (!this.canIPSendMoreToday(ipAddress)) {
                    logger.log('warn', `IP ${ipAddress} has reached its daily sending limit, email will be queued for later delivery`);
                }
                // Check if the IP can send more this hour
                if (!this.canIPSendMoreThisHour(ipAddress)) {
                    logger.log('warn', `IP ${ipAddress} has reached its hourly sending limit, email will be queued for later delivery`);
                }
                // Record the send for IP warmup tracking
                this.recordIPSend(ipAddress);
                // Add IP header to the email
                email.addHeader('X-Sending-IP', ipAddress);
            }
            // Check if the sender domain has DKIM keys and sign the email if needed
            if (mode === 'mta' && route?.action.options?.mtaOptions?.dkimSign) {
                const domain = email.from.split('@')[1];
                await this.handleDkimSigning(email, domain, route.action.options.mtaOptions.dkimOptions?.keySelector || 'mta');
            }
            // Generate a unique ID for this email
            const id = plugins.uuid.v4();
            // Queue the email for delivery
            await this.deliveryQueue.enqueue(email, mode, route);
            // Record 'sent' event for domain reputation monitoring
            const senderDomain = email.from.split('@')[1];
            if (senderDomain) {
                this.recordReputationEvent(senderDomain, {
                    type: 'sent',
                    count: email.to.length
                });
            }
            logger.log('info', `Email queued with ID: ${id}`);
            return id;
        }
        catch (error) {
            logger.log('error', `Failed to send email: ${error.message}`);
            throw error;
        }
    }
    /**
     * Handle DKIM signing for an email
     * @param email The email to sign
     * @param domain The domain to sign with
     * @param selector The DKIM selector
     */
    async handleDkimSigning(email, domain, selector) {
        try {
            // Ensure we have DKIM keys for this domain
            await this.dkimCreator.handleDKIMKeysForDomain(domain);
            // Get the private key
            const { privateKey } = await this.dkimCreator.readDKIMKeys(domain);
            // Convert Email to raw format for signing
            const rawEmail = email.toRFC822String();
            // Sign the email via Rust bridge
            const signResult = await this.rustBridge.signDkim({
                rawMessage: rawEmail,
                domain,
                selector,
                privateKey,
            });
            if (signResult.header) {
                email.addHeader('DKIM-Signature', signResult.header);
                logger.log('info', `Successfully added DKIM signature for ${domain}`);
            }
        }
        catch (error) {
            logger.log('error', `Failed to sign email with DKIM: ${error.message}`);
            // Continue without DKIM rather than failing the send
        }
    }
    /**
     * Process a bounce notification email
     * @param bounceEmail The email containing bounce notification information
     * @returns Processed bounce record or null if not a bounce
     */
    async processBounceNotification(bounceEmail) {
        logger.log('info', 'Processing potential bounce notification email');
        try {
            // Process as a bounce notification (no conversion needed anymore)
            const bounceRecord = await this.bounceManager.processBounceEmail(bounceEmail);
            if (bounceRecord) {
                logger.log('info', `Successfully processed bounce notification for ${bounceRecord.recipient}`, {
                    bounceType: bounceRecord.bounceType,
                    bounceCategory: bounceRecord.bounceCategory
                });
                // Notify any registered listeners about the bounce
                this.emit('bounceProcessed', bounceRecord);
                // Record bounce event for domain reputation tracking
                if (bounceRecord.domain) {
                    this.recordReputationEvent(bounceRecord.domain, {
                        type: 'bounce',
                        hardBounce: bounceRecord.bounceCategory === BounceCategory.HARD,
                        receivingDomain: bounceRecord.recipient.split('@')[1]
                    });
                }
                // Log security event
                SecurityLogger.getInstance().logEvent({
                    level: SecurityLogLevel.INFO,
                    type: SecurityEventType.EMAIL_VALIDATION,
                    message: `Bounce notification processed for recipient`,
                    domain: bounceRecord.domain,
                    details: {
                        recipient: bounceRecord.recipient,
                        bounceType: bounceRecord.bounceType,
                        bounceCategory: bounceRecord.bounceCategory
                    },
                    success: true
                });
                return true;
            }
            else {
                logger.log('info', 'Email not recognized as a bounce notification');
                return false;
            }
        }
        catch (error) {
            logger.log('error', `Error processing bounce notification: ${error.message}`);
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.ERROR,
                type: SecurityEventType.EMAIL_VALIDATION,
                message: 'Failed to process bounce notification',
                details: {
                    error: error.message,
                    subject: bounceEmail.subject
                },
                success: false
            });
            return false;
        }
    }
    /**
     * Process an SMTP failure as a bounce
     * @param recipient Recipient email that failed
     * @param smtpResponse SMTP error response
     * @param options Additional options for bounce processing
     * @returns Processed bounce record
     */
    async processSmtpFailure(recipient, smtpResponse, options = {}) {
        logger.log('info', `Processing SMTP failure for ${recipient}: ${smtpResponse}`);
        try {
            // Process the SMTP failure through the bounce manager
            const bounceRecord = await this.bounceManager.processSmtpFailure(recipient, smtpResponse, options);
            logger.log('info', `Successfully processed SMTP failure for ${recipient} as ${bounceRecord.bounceCategory} bounce`, {
                bounceType: bounceRecord.bounceType
            });
            // Notify any registered listeners about the bounce
            this.emit('bounceProcessed', bounceRecord);
            // Record bounce event for domain reputation tracking
            if (bounceRecord.domain) {
                this.recordReputationEvent(bounceRecord.domain, {
                    type: 'bounce',
                    hardBounce: bounceRecord.bounceCategory === BounceCategory.HARD,
                    receivingDomain: bounceRecord.recipient.split('@')[1]
                });
            }
            // Log security event
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.INFO,
                type: SecurityEventType.EMAIL_VALIDATION,
                message: `SMTP failure processed for recipient`,
                domain: bounceRecord.domain,
                details: {
                    recipient: bounceRecord.recipient,
                    bounceType: bounceRecord.bounceType,
                    bounceCategory: bounceRecord.bounceCategory,
                    smtpResponse
                },
                success: true
            });
            return true;
        }
        catch (error) {
            logger.log('error', `Error processing SMTP failure: ${error.message}`);
            SecurityLogger.getInstance().logEvent({
                level: SecurityLogLevel.ERROR,
                type: SecurityEventType.EMAIL_VALIDATION,
                message: 'Failed to process SMTP failure',
                details: {
                    recipient,
                    smtpResponse,
                    error: error.message
                },
                success: false
            });
            return false;
        }
    }
    /**
     * Check if an email address is suppressed (has bounced previously)
     * @param email Email address to check
     * @returns Whether the email is suppressed
     */
    isEmailSuppressed(email) {
        return this.bounceManager.isEmailSuppressed(email);
    }
    /**
     * Get suppression information for an email
     * @param email Email address to check
     * @returns Suppression information or null if not suppressed
     */
    getSuppressionInfo(email) {
        return this.bounceManager.getSuppressionInfo(email);
    }
    /**
     * Get bounce history information for an email
     * @param email Email address to check
     * @returns Bounce history or null if no bounces
     */
    getBounceHistory(email) {
        return this.bounceManager.getBounceInfo(email);
    }
    /**
     * Get all suppressed email addresses
     * @returns Array of suppressed email addresses
     */
    getSuppressionList() {
        return this.bounceManager.getSuppressionList();
    }
    /**
     * Get all hard bounced email addresses
     * @returns Array of hard bounced email addresses
     */
    getHardBouncedAddresses() {
        return this.bounceManager.getHardBouncedAddresses();
    }
    /**
     * Add an email to the suppression list
     * @param email Email address to suppress
     * @param reason Reason for suppression
     * @param expiresAt Optional expiration time (undefined for permanent)
     */
    addToSuppressionList(email, reason, expiresAt) {
        this.bounceManager.addToSuppressionList(email, reason, expiresAt);
        logger.log('info', `Added ${email} to suppression list: ${reason}`);
    }
    /**
     * Remove an email from the suppression list
     * @param email Email address to remove from suppression
     */
    removeFromSuppressionList(email) {
        this.bounceManager.removeFromSuppressionList(email);
        logger.log('info', `Removed ${email} from suppression list`);
    }
    /**
     * Get the status of IP warmup process
     * @param ipAddress Optional specific IP to check
     * @returns Status of IP warmup
     */
    getIPWarmupStatus(ipAddress) {
        return this.ipWarmupManager.getWarmupStatus(ipAddress);
    }
    /**
     * Add a new IP address to the warmup process
     * @param ipAddress IP address to add
     */
    addIPToWarmup(ipAddress) {
        this.ipWarmupManager.addIPToWarmup(ipAddress);
    }
    /**
     * Remove an IP address from the warmup process
     * @param ipAddress IP address to remove
     */
    removeIPFromWarmup(ipAddress) {
        this.ipWarmupManager.removeIPFromWarmup(ipAddress);
    }
    /**
     * Update metrics for an IP in the warmup process
     * @param ipAddress IP address
     * @param metrics Metrics to update
     */
    updateIPWarmupMetrics(ipAddress, metrics) {
        this.ipWarmupManager.updateMetrics(ipAddress, metrics);
    }
    /**
     * Check if an IP can send more emails today
     * @param ipAddress IP address to check
     * @returns Whether the IP can send more today
     */
    canIPSendMoreToday(ipAddress) {
        return this.ipWarmupManager.canSendMoreToday(ipAddress);
    }
    /**
     * Check if an IP can send more emails in the current hour
     * @param ipAddress IP address to check
     * @returns Whether the IP can send more this hour
     */
    canIPSendMoreThisHour(ipAddress) {
        return this.ipWarmupManager.canSendMoreThisHour(ipAddress);
    }
    /**
     * Get the best IP to use for sending an email based on warmup status
     * @param emailInfo Information about the email being sent
     * @returns Best IP to use or null
     */
    getBestIPForSending(emailInfo) {
        return this.ipWarmupManager.getBestIPForSending(emailInfo);
    }
    /**
     * Set the active IP allocation policy for warmup
     * @param policyName Name of the policy to set
     */
    setIPAllocationPolicy(policyName) {
        this.ipWarmupManager.setActiveAllocationPolicy(policyName);
    }
    /**
     * Record that an email was sent using a specific IP
     * @param ipAddress IP address used for sending
     */
    recordIPSend(ipAddress) {
        this.ipWarmupManager.recordSend(ipAddress);
    }
    /**
     * Get reputation data for a domain
     * @param domain Domain to get reputation for
     * @returns Domain reputation metrics
     */
    getDomainReputationData(domain) {
        return this.senderReputationMonitor.getReputationData(domain);
    }
    /**
     * Get summary reputation data for all monitored domains
     * @returns Summary data for all domains
     */
    getReputationSummary() {
        return this.senderReputationMonitor.getReputationSummary();
    }
    /**
     * Add a domain to the reputation monitoring system
     * @param domain Domain to add
     */
    addDomainToMonitoring(domain) {
        this.senderReputationMonitor.addDomain(domain);
    }
    /**
     * Remove a domain from the reputation monitoring system
     * @param domain Domain to remove
     */
    removeDomainFromMonitoring(domain) {
        this.senderReputationMonitor.removeDomain(domain);
    }
    /**
     * Record an email event for domain reputation tracking
     * @param domain Domain sending the email
     * @param event Event details
     */
    recordReputationEvent(domain, event) {
        this.senderReputationMonitor.recordSendEvent(domain, event);
    }
    /**
     * Check if DKIM key exists for a domain
     * @param domain Domain to check
     */
    hasDkimKey(domain) {
        return this.dkimKeys.has(domain);
    }
    /**
     * Record successful email delivery
     * @param domain Sending domain
     */
    recordDelivery(domain) {
        this.recordReputationEvent(domain, {
            type: 'delivered',
            count: 1
        });
    }
    /**
     * Record email bounce
     * @param domain Sending domain
     * @param receivingDomain Receiving domain that bounced
     * @param bounceType Type of bounce (hard/soft)
     * @param reason Bounce reason
     */
    recordBounce(domain, receivingDomain, bounceType, reason) {
        // Record bounce in bounce manager
        const bounceRecord = {
            id: `bounce_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
            recipient: `user@${receivingDomain}`,
            sender: `user@${domain}`,
            domain: domain,
            bounceType: bounceType === 'hard' ? BounceType.INVALID_RECIPIENT : BounceType.TEMPORARY_FAILURE,
            bounceCategory: bounceType === 'hard' ? BounceCategory.HARD : BounceCategory.SOFT,
            timestamp: Date.now(),
            smtpResponse: reason,
            diagnosticCode: reason,
            statusCode: bounceType === 'hard' ? '550' : '450',
            processed: false
        };
        // Process the bounce
        this.bounceManager.processBounce(bounceRecord);
        // Record reputation event
        this.recordReputationEvent(domain, {
            type: 'bounce',
            count: 1,
            hardBounce: bounceType === 'hard',
            receivingDomain
        });
    }
    /**
     * Get the rate limiter instance
     * @returns The unified rate limiter
     */
    getRateLimiter() {
        return this.rateLimiter;
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.unified.email.server.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.unified.email.server.ts"],"names":[],"mappings":"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"}