import { logger } from '../../logger.js';
/**
 * Rate limiter using token bucket algorithm
 * Provides more sophisticated rate limiting with burst handling
 */
export class RateLimiter {
    /** Rate limit configuration */
    config;
    /** Token buckets per key */
    buckets = new Map();
    /** Global bucket for non-keyed rate limiting */
    globalBucket;
    /**
     * Create a new rate limiter
     * @param config Rate limiter configuration
     */
    constructor(config) {
        // Set defaults
        this.config = {
            maxPerPeriod: config.maxPerPeriod,
            periodMs: config.periodMs,
            perKey: config.perKey ?? true,
            initialTokens: config.initialTokens ?? config.maxPerPeriod,
            burstTokens: config.burstTokens ?? 0,
            useGlobalLimit: config.useGlobalLimit ?? false
        };
        // Initialize global bucket
        this.globalBucket = {
            tokens: this.config.initialTokens,
            lastRefill: Date.now(),
            allowed: 0,
            denied: 0,
            errors: 0,
            firstErrorTime: 0
        };
        // Log initialization
        logger.log('info', `Rate limiter initialized: ${this.config.maxPerPeriod} per ${this.config.periodMs}ms${this.config.perKey ? ' per key' : ''}`);
    }
    /**
     * Check if a request is allowed under rate limits
     * @param key Key to check rate limit for (e.g. domain, user, IP)
     * @param cost Token cost (defaults to 1)
     * @returns Whether the request is allowed
     */
    isAllowed(key = 'global', cost = 1) {
        // If using global bucket directly, just check that
        if (key === 'global' || !this.config.perKey) {
            return this.checkBucket(this.globalBucket, cost);
        }
        // Get the key-specific bucket
        const bucket = this.getBucket(key);
        // If we also need to check global limit
        if (this.config.useGlobalLimit) {
            // Both key bucket and global bucket must have tokens
            return this.checkBucket(bucket, cost) && this.checkBucket(this.globalBucket, cost);
        }
        else {
            // Only need to check the key-specific bucket
            return this.checkBucket(bucket, cost);
        }
    }
    /**
     * Check if a bucket has enough tokens and consume them
     * @param bucket The token bucket to check
     * @param cost Token cost
     * @returns Whether tokens were consumed
     */
    checkBucket(bucket, cost) {
        // Refill tokens based on elapsed time
        this.refillBucket(bucket);
        // Check if we have enough tokens
        if (bucket.tokens >= cost) {
            // Use tokens
            bucket.tokens -= cost;
            bucket.allowed++;
            return true;
        }
        else {
            // Rate limit exceeded
            bucket.denied++;
            return false;
        }
    }
    /**
     * Consume tokens for a request (if available)
     * @param key Key to consume tokens for
     * @param cost Token cost (defaults to 1)
     * @returns Whether tokens were consumed
     */
    consume(key = 'global', cost = 1) {
        const isAllowed = this.isAllowed(key, cost);
        return isAllowed;
    }
    /**
     * Get the remaining tokens for a key
     * @param key Key to check
     * @returns Number of remaining tokens
     */
    getRemainingTokens(key = 'global') {
        const bucket = this.getBucket(key);
        this.refillBucket(bucket);
        return bucket.tokens;
    }
    /**
     * Get stats for a specific key
     * @param key Key to get stats for
     * @returns Rate limit statistics
     */
    getStats(key = 'global') {
        const bucket = this.getBucket(key);
        this.refillBucket(bucket);
        // Calculate time until next token
        const resetIn = bucket.tokens < this.config.maxPerPeriod ?
            Math.ceil(this.config.periodMs / this.config.maxPerPeriod) :
            0;
        return {
            remaining: bucket.tokens,
            limit: this.config.maxPerPeriod,
            resetIn,
            allowed: bucket.allowed,
            denied: bucket.denied
        };
    }
    /**
     * Get or create a token bucket for a key
     * @param key The rate limit key
     * @returns Token bucket
     */
    getBucket(key) {
        if (!this.config.perKey || key === 'global') {
            return this.globalBucket;
        }
        if (!this.buckets.has(key)) {
            // Create new bucket
            this.buckets.set(key, {
                tokens: this.config.initialTokens,
                lastRefill: Date.now(),
                allowed: 0,
                denied: 0,
                errors: 0,
                firstErrorTime: 0
            });
        }
        return this.buckets.get(key);
    }
    /**
     * Refill tokens in a bucket based on elapsed time
     * @param bucket Token bucket to refill
     */
    refillBucket(bucket) {
        const now = Date.now();
        const elapsedMs = now - bucket.lastRefill;
        // Calculate how many tokens to add
        const rate = this.config.maxPerPeriod / this.config.periodMs;
        const tokensToAdd = elapsedMs * rate;
        if (tokensToAdd >= 0.1) { // Allow for partial token refills
            // Add tokens, but don't exceed the normal maximum (without burst)
            // This ensures burst tokens are only used for bursts and don't refill
            const normalMax = this.config.maxPerPeriod;
            bucket.tokens = Math.min(
            // Don't exceed max + burst
            this.config.maxPerPeriod + (this.config.burstTokens || 0), 
            // Don't exceed normal max when refilling
            Math.min(normalMax, bucket.tokens + tokensToAdd));
            // Update last refill time
            bucket.lastRefill = now;
        }
    }
    /**
     * Reset rate limits for a specific key
     * @param key Key to reset
     */
    reset(key = 'global') {
        if (key === 'global' || !this.config.perKey) {
            this.globalBucket.tokens = this.config.initialTokens;
            this.globalBucket.lastRefill = Date.now();
        }
        else if (this.buckets.has(key)) {
            const bucket = this.buckets.get(key);
            bucket.tokens = this.config.initialTokens;
            bucket.lastRefill = Date.now();
        }
    }
    /**
     * Reset all rate limiters
     */
    resetAll() {
        this.globalBucket.tokens = this.config.initialTokens;
        this.globalBucket.lastRefill = Date.now();
        for (const bucket of this.buckets.values()) {
            bucket.tokens = this.config.initialTokens;
            bucket.lastRefill = Date.now();
        }
    }
    /**
     * Cleanup old buckets to prevent memory leaks
     * @param maxAge Maximum age in milliseconds
     */
    cleanup(maxAge = 24 * 60 * 60 * 1000) {
        const now = Date.now();
        let removed = 0;
        for (const [key, bucket] of this.buckets.entries()) {
            if (now - bucket.lastRefill > maxAge) {
                this.buckets.delete(key);
                removed++;
            }
        }
        if (removed > 0) {
            logger.log('debug', `Cleaned up ${removed} stale rate limit buckets`);
        }
    }
    /**
     * Record an error for a key (e.g., IP address) and determine if blocking is needed
     * RFC 5321 Section 4.5.4.1 suggests limiting errors to prevent abuse
     *
     * @param key Key to record error for (typically an IP address)
     * @param errorWindow Time window for error tracking in ms (default: 5 minutes)
     * @param errorThreshold Maximum errors before blocking (default: 10)
     * @returns true if the key should be blocked due to excessive errors
     */
    recordError(key, errorWindow = 5 * 60 * 1000, errorThreshold = 10) {
        const bucket = this.getBucket(key);
        const now = Date.now();
        // Reset error count if the time window has expired
        if (bucket.firstErrorTime === 0 || now - bucket.firstErrorTime > errorWindow) {
            bucket.errors = 0;
            bucket.firstErrorTime = now;
        }
        // Increment error count
        bucket.errors++;
        // Log error tracking
        logger.log('debug', `Error recorded for ${key}: ${bucket.errors}/${errorThreshold} in window`);
        // Check if threshold exceeded
        if (bucket.errors >= errorThreshold) {
            logger.log('warn', `Error threshold exceeded for ${key}: ${bucket.errors} errors`);
            return true; // Should block
        }
        return false; // Continue allowing
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.ratelimiter.js","sourceRoot":"","sources":["../../../ts/mail/delivery/classes.ratelimiter.ts"],"names":[],"mappings":"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"}