import * as plugins from '../../plugins.js';
import * as paths from '../../paths.js';
import { DKIMCreator } from '../security/classes.dkimcreator.js';
/**
 * Manager for DNS-related operations, including record lookups, verification, and generation
 */
export class DNSManager {
    dkimCreator;
    cache = new Map();
    defaultOptions = {
        cacheTtl: 300000, // 5 minutes
        timeout: 5000 // 5 seconds
    };
    constructor(dkimCreatorArg, options) {
        this.dkimCreator = dkimCreatorArg;
        if (options) {
            this.defaultOptions = {
                ...this.defaultOptions,
                ...options
            };
        }
        // Ensure the DNS records directory exists
        plugins.fs.mkdirSync(paths.dnsRecordsDir, { recursive: true });
    }
    /**
     * Lookup MX records for a domain
     * @param domain Domain to look up
     * @param options Lookup options
     * @returns Array of MX records sorted by priority
     */
    async lookupMx(domain, options) {
        const lookupOptions = { ...this.defaultOptions, ...options };
        const cacheKey = `mx:${domain}`;
        // Check cache first
        const cached = this.getFromCache(cacheKey);
        if (cached) {
            return cached;
        }
        try {
            const records = await this.dnsResolveMx(domain, lookupOptions.timeout);
            // Sort by priority
            records.sort((a, b) => a.priority - b.priority);
            // Cache the result
            this.setInCache(cacheKey, records, lookupOptions.cacheTtl);
            return records;
        }
        catch (error) {
            console.error(`Error looking up MX records for ${domain}:`, error);
            throw new Error(`Failed to lookup MX records for ${domain}: ${error.message}`);
        }
    }
    /**
     * Lookup TXT records for a domain
     * @param domain Domain to look up
     * @param options Lookup options
     * @returns Array of TXT records
     */
    async lookupTxt(domain, options) {
        const lookupOptions = { ...this.defaultOptions, ...options };
        const cacheKey = `txt:${domain}`;
        // Check cache first
        const cached = this.getFromCache(cacheKey);
        if (cached) {
            return cached;
        }
        try {
            const records = await this.dnsResolveTxt(domain, lookupOptions.timeout);
            // Cache the result
            this.setInCache(cacheKey, records, lookupOptions.cacheTtl);
            return records;
        }
        catch (error) {
            console.error(`Error looking up TXT records for ${domain}:`, error);
            throw new Error(`Failed to lookup TXT records for ${domain}: ${error.message}`);
        }
    }
    /**
     * Find specific TXT record by subdomain and prefix
     * @param domain Base domain
     * @param subdomain Subdomain prefix (e.g., "dkim._domainkey")
     * @param prefix Record prefix to match (e.g., "v=DKIM1")
     * @param options Lookup options
     * @returns Matching TXT record or null if not found
     */
    async findTxtRecord(domain, subdomain = '', prefix = '', options) {
        const fullDomain = subdomain ? `${subdomain}.${domain}` : domain;
        try {
            const records = await this.lookupTxt(fullDomain, options);
            for (const recordArray of records) {
                // TXT records can be split into chunks, join them
                const record = recordArray.join('');
                if (!prefix || record.startsWith(prefix)) {
                    return record;
                }
            }
            return null;
        }
        catch (error) {
            // Domain might not exist or no TXT records
            console.log(`No matching TXT record found for ${fullDomain} with prefix ${prefix}`);
            return null;
        }
    }
    /**
     * Verify if a domain has a valid SPF record
     * @param domain Domain to verify
     * @returns Verification result
     */
    async verifySpfRecord(domain) {
        const result = {
            record: 'SPF',
            found: false,
            valid: false
        };
        try {
            const spfRecord = await this.findTxtRecord(domain, '', 'v=spf1');
            if (spfRecord) {
                result.found = true;
                result.value = spfRecord;
                // Basic validation - check if it contains all, include, ip4, ip6, or mx mechanisms
                const isValid = /v=spf1\s+([-~?+]?(all|include:|ip4:|ip6:|mx|a|exists:))/.test(spfRecord);
                result.valid = isValid;
                if (!isValid) {
                    result.error = 'SPF record format is invalid';
                }
            }
            else {
                result.error = 'No SPF record found';
            }
        }
        catch (error) {
            result.error = `Error verifying SPF: ${error.message}`;
        }
        return result;
    }
    /**
     * Verify if a domain has a valid DKIM record
     * @param domain Domain to verify
     * @param selector DKIM selector (usually "mta" in our case)
     * @returns Verification result
     */
    async verifyDkimRecord(domain, selector = 'mta') {
        const result = {
            record: 'DKIM',
            found: false,
            valid: false
        };
        try {
            const dkimSelector = `${selector}._domainkey`;
            const dkimRecord = await this.findTxtRecord(domain, dkimSelector, 'v=DKIM1');
            if (dkimRecord) {
                result.found = true;
                result.value = dkimRecord;
                // Basic validation - check for required fields
                const hasP = dkimRecord.includes('p=');
                result.valid = dkimRecord.includes('v=DKIM1') && hasP;
                if (!result.valid) {
                    result.error = 'DKIM record is missing required fields';
                }
                else if (dkimRecord.includes('p=') && !dkimRecord.match(/p=[a-zA-Z0-9+/]+/)) {
                    result.valid = false;
                    result.error = 'DKIM record has invalid public key format';
                }
            }
            else {
                result.error = `No DKIM record found for selector ${selector}`;
            }
        }
        catch (error) {
            result.error = `Error verifying DKIM: ${error.message}`;
        }
        return result;
    }
    /**
     * Verify if a domain has a valid DMARC record
     * @param domain Domain to verify
     * @returns Verification result
     */
    async verifyDmarcRecord(domain) {
        const result = {
            record: 'DMARC',
            found: false,
            valid: false
        };
        try {
            const dmarcDomain = `_dmarc.${domain}`;
            const dmarcRecord = await this.findTxtRecord(dmarcDomain, '', 'v=DMARC1');
            if (dmarcRecord) {
                result.found = true;
                result.value = dmarcRecord;
                // Basic validation - check for required fields
                const hasPolicy = dmarcRecord.includes('p=');
                result.valid = dmarcRecord.includes('v=DMARC1') && hasPolicy;
                if (!result.valid) {
                    result.error = 'DMARC record is missing required fields';
                }
            }
            else {
                result.error = 'No DMARC record found';
            }
        }
        catch (error) {
            result.error = `Error verifying DMARC: ${error.message}`;
        }
        return result;
    }
    /**
     * Check all email authentication records (SPF, DKIM, DMARC) for a domain
     * @param domain Domain to check
     * @param dkimSelector DKIM selector
     * @returns Object with verification results for each record type
     */
    async verifyEmailAuthRecords(domain, dkimSelector = 'mta') {
        const [spf, dkim, dmarc] = await Promise.all([
            this.verifySpfRecord(domain),
            this.verifyDkimRecord(domain, dkimSelector),
            this.verifyDmarcRecord(domain)
        ]);
        return { spf, dkim, dmarc };
    }
    /**
     * Generate a recommended SPF record for a domain
     * @param domain Domain name
     * @param options Configuration options for the SPF record
     * @returns Generated SPF record
     */
    generateSpfRecord(domain, options = {}) {
        const { includeMx = true, includeA = true, includeIps = [], includeSpf = [], policy = 'softfail' } = options;
        let value = 'v=spf1';
        if (includeMx) {
            value += ' mx';
        }
        if (includeA) {
            value += ' a';
        }
        // Add IP addresses
        for (const ip of includeIps) {
            if (ip.includes(':')) {
                value += ` ip6:${ip}`;
            }
            else {
                value += ` ip4:${ip}`;
            }
        }
        // Add includes
        for (const include of includeSpf) {
            value += ` include:${include}`;
        }
        // Add policy
        const policyMap = {
            'none': '?all',
            'neutral': '~all',
            'softfail': '~all',
            'fail': '-all',
            'reject': '-all'
        };
        value += ` ${policyMap[policy]}`;
        return {
            name: domain,
            type: 'TXT',
            value: value
        };
    }
    /**
     * Generate a recommended DMARC record for a domain
     * @param domain Domain name
     * @param options Configuration options for the DMARC record
     * @returns Generated DMARC record
     */
    generateDmarcRecord(domain, options = {}) {
        const { policy = 'none', subdomainPolicy, pct = 100, rua, ruf, daysInterval = 1 } = options;
        let value = 'v=DMARC1; p=' + policy;
        if (subdomainPolicy) {
            value += `; sp=${subdomainPolicy}`;
        }
        if (pct !== 100) {
            value += `; pct=${pct}`;
        }
        if (rua) {
            value += `; rua=mailto:${rua}`;
        }
        if (ruf) {
            value += `; ruf=mailto:${ruf}`;
        }
        if (daysInterval !== 1) {
            value += `; ri=${daysInterval * 86400}`;
        }
        // Add reporting format and ADKIM/ASPF alignment
        value += '; fo=1; adkim=r; aspf=r';
        return {
            name: `_dmarc.${domain}`,
            type: 'TXT',
            value: value
        };
    }
    /**
     * Save DNS record recommendations to a file
     * @param domain Domain name
     * @param records DNS records to save
     */
    async saveDnsRecommendations(domain, records) {
        try {
            const filePath = plugins.path.join(paths.dnsRecordsDir, `${domain}.recommendations.json`);
            await plugins.smartfs.file(filePath).write(JSON.stringify(records, null, 2));
            console.log(`DNS recommendations for ${domain} saved to ${filePath}`);
        }
        catch (error) {
            console.error(`Error saving DNS recommendations for ${domain}:`, error);
        }
    }
    /**
     * Get cache key value
     * @param key Cache key
     * @returns Cached value or undefined if not found or expired
     */
    getFromCache(key) {
        const cached = this.cache.get(key);
        if (cached && cached.expires > Date.now()) {
            return cached.data;
        }
        // Remove expired entry
        if (cached) {
            this.cache.delete(key);
        }
        return undefined;
    }
    /**
     * Set cache key value
     * @param key Cache key
     * @param data Data to cache
     * @param ttl TTL in milliseconds
     */
    setInCache(key, data, ttl = this.defaultOptions.cacheTtl) {
        if (ttl <= 0)
            return; // Don't cache if TTL is disabled
        this.cache.set(key, {
            data,
            expires: Date.now() + ttl
        });
    }
    /**
     * Clear the DNS cache
     * @param key Optional specific key to clear, or all cache if not provided
     */
    clearCache(key) {
        if (key) {
            this.cache.delete(key);
        }
        else {
            this.cache.clear();
        }
    }
    /**
     * Promise-based wrapper for dns.resolveMx
     * @param domain Domain to resolve
     * @param timeout Timeout in milliseconds
     * @returns Promise resolving to MX records
     */
    dnsResolveMx(domain, timeout = 5000) {
        return new Promise((resolve, reject) => {
            const timeoutId = setTimeout(() => {
                reject(new Error(`DNS MX lookup timeout for ${domain}`));
            }, timeout);
            plugins.dns.resolveMx(domain, (err, addresses) => {
                clearTimeout(timeoutId);
                if (err) {
                    reject(err);
                }
                else {
                    resolve(addresses);
                }
            });
        });
    }
    /**
     * Promise-based wrapper for dns.resolveTxt
     * @param domain Domain to resolve
     * @param timeout Timeout in milliseconds
     * @returns Promise resolving to TXT records
     */
    dnsResolveTxt(domain, timeout = 5000) {
        return new Promise((resolve, reject) => {
            const timeoutId = setTimeout(() => {
                reject(new Error(`DNS TXT lookup timeout for ${domain}`));
            }, timeout);
            plugins.dns.resolveTxt(domain, (err, records) => {
                clearTimeout(timeoutId);
                if (err) {
                    reject(err);
                }
                else {
                    resolve(records);
                }
            });
        });
    }
    /**
     * Generate all recommended DNS records for proper email authentication
     * @param domain Domain to generate records for
     * @returns Array of recommended DNS records
     */
    async generateAllRecommendedRecords(domain) {
        const records = [];
        // Get DKIM record (already created by DKIMCreator)
        try {
            // Call the DKIM creator directly
            const dkimRecord = await this.dkimCreator.getDNSRecordForDomain(domain);
            records.push(dkimRecord);
        }
        catch (error) {
            console.error(`Error getting DKIM record for ${domain}:`, error);
        }
        // Generate SPF record
        const spfRecord = this.generateSpfRecord(domain, {
            includeMx: true,
            includeA: true,
            policy: 'softfail'
        });
        records.push(spfRecord);
        // Generate DMARC record
        const dmarcRecord = this.generateDmarcRecord(domain, {
            policy: 'none', // Start with monitoring mode
            rua: `dmarc@${domain}` // Replace with appropriate report address
        });
        records.push(dmarcRecord);
        // Save recommendations
        await this.saveDnsRecommendations(domain, records);
        return records;
    }
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.dnsmanager.js","sourceRoot":"","sources":["../../../ts/mail/routing/classes.dnsmanager.ts"],"names":[],"mappings":"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"}