import * as plugins from '../../plugins.js';
/**
 * Collection of validation utilities for configuration and domain options
 */
export class ValidationUtils {
    /**
     * Validates domain configuration options
     *
     * @param domainOptions The domain options to validate
     * @returns An object with validation result and error message if invalid
     */
    static validateDomainOptions(domainOptions) {
        if (!domainOptions) {
            return { isValid: false, error: 'Domain options cannot be null or undefined' };
        }
        if (!domainOptions.domainName) {
            return { isValid: false, error: 'Domain name is required' };
        }
        // Check domain pattern
        if (!this.isValidDomainName(domainOptions.domainName)) {
            return { isValid: false, error: `Invalid domain name: ${domainOptions.domainName}` };
        }
        // Validate forward config if provided
        if (domainOptions.forward) {
            if (!domainOptions.forward.ip) {
                return { isValid: false, error: 'Forward IP is required when forward is specified' };
            }
            if (!domainOptions.forward.port) {
                return { isValid: false, error: 'Forward port is required when forward is specified' };
            }
            if (!this.isValidPort(domainOptions.forward.port)) {
                return { isValid: false, error: `Invalid forward port: ${domainOptions.forward.port}` };
            }
        }
        // Validate ACME forward config if provided
        if (domainOptions.acmeForward) {
            if (!domainOptions.acmeForward.ip) {
                return { isValid: false, error: 'ACME forward IP is required when acmeForward is specified' };
            }
            if (!domainOptions.acmeForward.port) {
                return { isValid: false, error: 'ACME forward port is required when acmeForward is specified' };
            }
            if (!this.isValidPort(domainOptions.acmeForward.port)) {
                return { isValid: false, error: `Invalid ACME forward port: ${domainOptions.acmeForward.port}` };
            }
        }
        return { isValid: true };
    }
    /**
     * Validates ACME configuration options
     *
     * @param acmeOptions The ACME options to validate
     * @returns An object with validation result and error message if invalid
     */
    static validateAcmeOptions(acmeOptions) {
        if (!acmeOptions) {
            return { isValid: false, error: 'ACME options cannot be null or undefined' };
        }
        if (acmeOptions.enabled) {
            if (!acmeOptions.accountEmail) {
                return { isValid: false, error: 'Account email is required when ACME is enabled' };
            }
            if (!this.isValidEmail(acmeOptions.accountEmail)) {
                return { isValid: false, error: `Invalid email: ${acmeOptions.accountEmail}` };
            }
            if (acmeOptions.port && !this.isValidPort(acmeOptions.port)) {
                return { isValid: false, error: `Invalid ACME port: ${acmeOptions.port}` };
            }
            if (acmeOptions.httpsRedirectPort && !this.isValidPort(acmeOptions.httpsRedirectPort)) {
                return { isValid: false, error: `Invalid HTTPS redirect port: ${acmeOptions.httpsRedirectPort}` };
            }
            if (acmeOptions.renewThresholdDays && acmeOptions.renewThresholdDays < 1) {
                return { isValid: false, error: 'Renew threshold days must be greater than 0' };
            }
            if (acmeOptions.renewCheckIntervalHours && acmeOptions.renewCheckIntervalHours < 1) {
                return { isValid: false, error: 'Renew check interval hours must be greater than 0' };
            }
        }
        return { isValid: true };
    }
    /**
     * Validates a port number
     *
     * @param port The port to validate
     * @returns true if the port is valid, false otherwise
     */
    static isValidPort(port) {
        return typeof port === 'number' && port > 0 && port <= 65535 && Number.isInteger(port);
    }
    /**
     * Validates a domain name
     *
     * @param domain The domain name to validate
     * @returns true if the domain name is valid, false otherwise
     */
    static isValidDomainName(domain) {
        if (!domain || typeof domain !== 'string') {
            return false;
        }
        // Wildcard domain check (*.example.com)
        if (domain.startsWith('*.')) {
            domain = domain.substring(2);
        }
        // Simple domain validation pattern
        const domainPattern = /^([a-zA-Z0-9]([a-zA-Z0-9\-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
        return domainPattern.test(domain);
    }
    /**
     * Validates an email address
     *
     * @param email The email to validate
     * @returns true if the email is valid, false otherwise
     */
    static isValidEmail(email) {
        if (!email || typeof email !== 'string') {
            return false;
        }
        // Basic email validation pattern
        const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
        return emailPattern.test(email);
    }
    /**
     * Validates a certificate format (PEM)
     *
     * @param cert The certificate content to validate
     * @returns true if the certificate appears to be in PEM format, false otherwise
     */
    static isValidCertificate(cert) {
        if (!cert || typeof cert !== 'string') {
            return false;
        }
        return cert.includes('-----BEGIN CERTIFICATE-----') &&
            cert.includes('-----END CERTIFICATE-----');
    }
    /**
     * Validates a private key format (PEM)
     *
     * @param key The private key content to validate
     * @returns true if the key appears to be in PEM format, false otherwise
     */
    static isValidPrivateKey(key) {
        if (!key || typeof key !== 'string') {
            return false;
        }
        return key.includes('-----BEGIN PRIVATE KEY-----') &&
            key.includes('-----END PRIVATE KEY-----');
    }
}
//# sourceMappingURL=data:application/json;base64, 