/**
 * SMTP Client Connection Manager
 * Connection pooling and lifecycle management
 */
import * as net from 'node:net';
import * as tls from 'node:tls';
import { EventEmitter } from 'node:events';
import { DEFAULTS, CONNECTION_STATES } from './constants.js';
import { logConnection, logDebug } from './utils/logging.js';
import { generateConnectionId } from './utils/helpers.js';
export class ConnectionManager extends EventEmitter {
    options;
    connections = new Map();
    pendingConnections = new Set();
    idleTimeout = null;
    constructor(options) {
        super();
        this.options = options;
        this.setupIdleCleanup();
    }
    /**
     * Get or create a connection
     */
    async getConnection() {
        // Try to reuse an idle connection if pooling is enabled
        if (this.options.pool) {
            const idleConnection = this.findIdleConnection();
            if (idleConnection) {
                const connectionId = this.getConnectionId(idleConnection) || 'unknown';
                logDebug('Reusing idle connection', this.options, { connectionId });
                return idleConnection;
            }
            // Check if we can create a new connection
            if (this.getActiveConnectionCount() >= (this.options.maxConnections || DEFAULTS.MAX_CONNECTIONS)) {
                throw new Error('Maximum number of connections reached');
            }
        }
        return this.createConnection();
    }
    /**
     * Create a new connection
     */
    async createConnection() {
        const connectionId = generateConnectionId();
        try {
            this.pendingConnections.add(connectionId);
            logConnection('connecting', this.options, { connectionId });
            const socket = await this.establishSocket();
            const connection = {
                socket,
                state: CONNECTION_STATES.CONNECTED,
                options: this.options,
                secure: this.options.secure || false,
                createdAt: new Date(),
                lastActivity: new Date(),
                messageCount: 0
            };
            this.setupSocketHandlers(socket, connectionId);
            this.connections.set(connectionId, connection);
            this.pendingConnections.delete(connectionId);
            logConnection('connected', this.options, { connectionId });
            this.emit('connection', connection);
            return connection;
        }
        catch (error) {
            this.pendingConnections.delete(connectionId);
            logConnection('error', this.options, { connectionId, error });
            throw error;
        }
    }
    /**
     * Release a connection back to the pool or close it
     */
    releaseConnection(connection) {
        const connectionId = this.getConnectionId(connection);
        if (!connectionId || !this.connections.has(connectionId)) {
            return;
        }
        if (this.options.pool && this.shouldReuseConnection(connection)) {
            // Return to pool
            connection.state = CONNECTION_STATES.READY;
            connection.lastActivity = new Date();
            logDebug('Connection returned to pool', this.options, { connectionId });
        }
        else {
            // Close connection
            this.closeConnection(connection);
        }
    }
    /**
     * Close a specific connection
     */
    closeConnection(connection) {
        const connectionId = this.getConnectionId(connection);
        if (connectionId) {
            this.connections.delete(connectionId);
        }
        connection.state = CONNECTION_STATES.CLOSING;
        try {
            if (!connection.socket.destroyed) {
                connection.socket.destroy();
            }
        }
        catch (error) {
            logDebug('Error closing connection', this.options, { error });
        }
        logConnection('disconnected', this.options, { connectionId });
        this.emit('disconnect', connection);
    }
    /**
     * Close all connections
     */
    closeAllConnections() {
        logDebug('Closing all connections', this.options);
        for (const connection of this.connections.values()) {
            this.closeConnection(connection);
        }
        this.connections.clear();
        this.pendingConnections.clear();
        if (this.idleTimeout) {
            clearInterval(this.idleTimeout);
            this.idleTimeout = null;
        }
    }
    /**
     * Get connection pool status
     */
    getPoolStatus() {
        const total = this.connections.size;
        const active = Array.from(this.connections.values())
            .filter(conn => conn.state === CONNECTION_STATES.BUSY).length;
        const idle = total - active;
        const pending = this.pendingConnections.size;
        return { total, active, idle, pending };
    }
    /**
     * Update connection activity timestamp
     */
    updateActivity(connection) {
        connection.lastActivity = new Date();
    }
    async establishSocket() {
        return new Promise((resolve, reject) => {
            const timeout = this.options.connectionTimeout || DEFAULTS.CONNECTION_TIMEOUT;
            let socket;
            if (this.options.secure) {
                // Direct TLS connection
                socket = tls.connect({
                    host: this.options.host,
                    port: this.options.port,
                    ...this.options.tls
                });
            }
            else {
                // Plain connection
                socket = new net.Socket();
                socket.connect(this.options.port, this.options.host);
            }
            const timeoutHandler = setTimeout(() => {
                socket.destroy();
                reject(new Error(`Connection timeout after ${timeout}ms`));
            }, timeout);
            // For TLS connections, we need to wait for 'secureConnect' instead of 'connect'
            const successEvent = this.options.secure ? 'secureConnect' : 'connect';
            socket.once(successEvent, () => {
                clearTimeout(timeoutHandler);
                resolve(socket);
            });
            socket.once('error', (error) => {
                clearTimeout(timeoutHandler);
                reject(error);
            });
        });
    }
    setupSocketHandlers(socket, connectionId) {
        const socketTimeout = this.options.socketTimeout || DEFAULTS.SOCKET_TIMEOUT;
        socket.setTimeout(socketTimeout);
        socket.on('timeout', () => {
            logDebug('Socket timeout', this.options, { connectionId });
            socket.destroy();
        });
        socket.on('error', (error) => {
            logConnection('error', this.options, { connectionId, error });
            this.connections.delete(connectionId);
        });
        socket.on('close', () => {
            this.connections.delete(connectionId);
            logDebug('Socket closed', this.options, { connectionId });
        });
    }
    findIdleConnection() {
        for (const connection of this.connections.values()) {
            if (connection.state === CONNECTION_STATES.READY) {
                return connection;
            }
        }
        return null;
    }
    shouldReuseConnection(connection) {
        const maxMessages = this.options.maxMessages || DEFAULTS.MAX_MESSAGES;
        const maxAge = 300000; // 5 minutes
        const age = Date.now() - connection.createdAt.getTime();
        return connection.messageCount < maxMessages &&
            age < maxAge &&
            !connection.socket.destroyed;
    }
    getActiveConnectionCount() {
        return this.connections.size + this.pendingConnections.size;
    }
    getConnectionId(connection) {
        for (const [id, conn] of this.connections.entries()) {
            if (conn === connection) {
                return id;
            }
        }
        return null;
    }
    setupIdleCleanup() {
        if (!this.options.pool) {
            return;
        }
        const cleanupInterval = DEFAULTS.POOL_IDLE_TIMEOUT;
        this.idleTimeout = setInterval(() => {
            const now = Date.now();
            const connectionsToClose = [];
            for (const connection of this.connections.values()) {
                const idleTime = now - connection.lastActivity.getTime();
                if (connection.state === CONNECTION_STATES.READY && idleTime > cleanupInterval) {
                    connectionsToClose.push(connection);
                }
            }
            for (const connection of connectionsToClose) {
                logDebug('Closing idle connection', this.options);
                this.closeConnection(connection);
            }
        }, cleanupInterval);
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"connection-manager.js","sourceRoot":"","sources":["../../../../ts/mail/delivery/smtpclient/connection-manager.ts"],"names":[],"mappings":"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"}