<?php
/**
 * Settings management class
 */

// Prevent direct access
if (!defined('ABSPATH')) {
    exit;
}

class AHA_Mail_SMTP_Settings {
    
    /**
     * Single instance of the class
     */
    private static $instance = null;
    
    /**
     * Settings option prefix
     */
    const OPTION_PREFIX = 'aha_mail_smtp_';
    
    /**
     * Get single instance
     */
    public static function get_instance() {
        if (null === self::$instance) {
            self::$instance = new self();
        }
        return self::$instance;
    }
    
    /**
     * Constructor
     */
    private function __construct() {
        // Settings are managed through WordPress options API
    }
    
    /**
     * Get a setting value
     */
    public static function get($key, $default = '') {
        return get_option(self::OPTION_PREFIX . $key, $default);
    }
    
    /**
     * Set a setting value
     */
    public static function set($key, $value) {
        return update_option(self::OPTION_PREFIX . $key, $value);
    }
    
    /**
     * Delete a setting
     */
    public static function delete($key) {
        return delete_option(self::OPTION_PREFIX . $key);
    }
    
    /**
     * Get all settings
     */
    public static function get_all_settings() {
        $default_settings = array(
            'smtp_host' => '',
            'smtp_port' => 587,
            'smtp_encryption' => 'tls',
            'smtp_auth' => true,
            'smtp_username' => '',
            'smtp_password' => '',
            'from_email' => get_option('admin_email'),
            'from_name' => get_bloginfo('name'),
            'force_from' => false, // Deprecated: Use force_from_email and force_from_name
            'force_from_email' => false,
            'force_from_name' => false,
            'reply_to_email' => '',
            'return_path' => '',
            'enable_logging' => true,
            'debug_mode' => false,
            'provider' => 'generic',
            'connection_mode' => 'smtp',
            // API settings (dynamic based on provider)
            'api_key' => '',
            'api_secret' => '',
            'api_domain' => '',
            'api_region' => '',
            'client_id' => '',
            'client_secret' => ''
        );
        
        $settings = array();
        foreach ($default_settings as $key => $default_value) {
            $settings[$key] = self::get($key, $default_value);
        }
        
        return $settings;
    }
    
    /**
     * Save multiple settings at once
     */
    public static function save_settings($settings) {
        $allowed_settings = array(
            'smtp_host', 'smtp_port', 'smtp_encryption', 'smtp_auth',
            'smtp_username', 'smtp_password', 'from_email', 'from_name',
            'force_from', 'force_from_email', 'force_from_name', 
            'reply_to_email', 'return_path', 'enable_logging',
            'debug_mode', 'provider', 'connection_mode',
            // API settings
            'api_key', 'api_secret', 'api_domain', 'api_region',
            'client_id', 'client_secret'
        );
        
        $saved = array();
        foreach ($settings as $key => $value) {
            if (in_array($key, $allowed_settings)) {
                // Sanitize based on field type
                $sanitized_value = self::sanitize_setting($key, $value);
                if (self::set($key, $sanitized_value)) {
                    $saved[$key] = $sanitized_value;
                }
            }
        }
        
        return $saved;
    }
    
    /**
     * Sanitize setting value based on key
     */
    private static function sanitize_setting($key, $value) {
        switch ($key) {
            case 'smtp_port':
                return intval($value);
                
            case 'smtp_auth':
            case 'force_from':
            case 'force_from_email':
            case 'force_from_name':
            case 'enable_logging':
            case 'debug_mode':
                return (bool) $value;
                
            case 'from_email':
            case 'reply_to_email':
            case 'return_path':
                return sanitize_email($value);
                
            case 'smtp_password':
            case 'api_key':
            case 'api_secret':
            case 'client_secret':
                // Don't sanitize passwords/keys too aggressively
                return $value;
                
            default:
                return sanitize_text_field($value);
        }
    }
    
    /**
     * Reset all settings to defaults
     */
    public static function reset_settings() {
        $all_options = wp_load_alloptions();
        
        foreach ($all_options as $option_name => $option_value) {
            if (strpos($option_name, self::OPTION_PREFIX) === 0) {
                delete_option($option_name);
            }
        }
        
        return true;
    }
    
    /**
     * Export settings to array
     */
    public static function export_settings() {
        $settings = self::get_all_settings();
        
        // Remove sensitive data from export
        unset($settings['smtp_password']);
        unset($settings['api_key']);
        unset($settings['api_secret']);
        unset($settings['client_secret']);
        
        return $settings;
    }
    
    /**
     * Import settings from array
     */
    public static function import_settings($settings) {
        if (!is_array($settings)) {
            return false;
        }
        
        return self::save_settings($settings);
    }
    
    /**
     * Get provider-specific API fields
     */
    public static function get_provider_api_fields($provider) {
        $providers = AHA_Mail_SMTP_Core::get_smtp_providers();
        
        if (!isset($providers[$provider]) || !isset($providers[$provider]['api_fields'])) {
            return array();
        }
        
        return $providers[$provider]['api_fields'];
    }
    
    /**
     * Get current provider API settings
     */
    public static function get_provider_api_settings($provider = null) {
        if (!$provider) {
            $provider = self::get('provider', 'generic');
        }
        
        $api_fields = self::get_provider_api_fields($provider);
        $api_settings = array();
        
        foreach ($api_fields as $field_key => $field_config) {
            $api_settings[$field_key] = self::get($field_key, '');
        }
        
        return $api_settings;
    }
    
    /**
     * Validate SMTP settings
     */
    public static function validate_smtp_settings($settings) {
        $errors = array();
        
        // Required fields for SMTP
        if (empty($settings['smtp_host'])) {
            $errors[] = __('SMTP Host is required', 'aha-mail-smtp');
        }
        
        if (empty($settings['smtp_port']) || !is_numeric($settings['smtp_port'])) {
            $errors[] = __('Valid SMTP Port is required', 'aha-mail-smtp');
        }
        
        if ($settings['smtp_auth'] && empty($settings['smtp_username'])) {
            $errors[] = __('SMTP Username is required when authentication is enabled', 'aha-mail-smtp');
        }
        
        if ($settings['smtp_auth'] && empty($settings['smtp_password'])) {
            $errors[] = __('SMTP Password is required when authentication is enabled', 'aha-mail-smtp');
        }
        
        if (!empty($settings['from_email']) && !is_email($settings['from_email'])) {
            $errors[] = __('From Email must be a valid email address', 'aha-mail-smtp');
        }
        
        return $errors;
    }
    
    /**
     * Validate API settings
     */
    public static function validate_api_settings($settings, $provider) {
        $errors = array();
        $api_fields = self::get_provider_api_fields($provider);
        
        foreach ($api_fields as $field_key => $field_config) {
            if (empty($settings[$field_key])) {
                $errors[] = sprintf(__('%s is required for %s API connection', 'aha-mail-smtp'), 
                    $field_config['label'], 
                    $provider
                );
            }
        }
        
        return $errors;
    }
    
    /**
     * Get connection status
     */
    public static function get_connection_status() {
        $settings = self::get_all_settings();
        $provider = $settings['provider'];
        $mode = $settings['connection_mode'];
        
        $status = array(
            'configured' => false,
            'provider' => $provider,
            'mode' => $mode,
            'errors' => array()
        );
        
        if ($mode === 'api') {
            $errors = self::validate_api_settings($settings, $provider);
        } else {
            $errors = self::validate_smtp_settings($settings);
        }
        
        $status['configured'] = empty($errors);
        $status['errors'] = $errors;
        
        return $status;
    }
    
    /**
     * Get settings for specific provider
     */
    public static function get_provider_settings($provider) {
        $providers = AHA_Mail_SMTP_Core::get_smtp_providers();
        
        if (!isset($providers[$provider])) {
            return false;
        }
        
        return $providers[$provider];
    }
    
    /**
     * Check if provider supports API
     */
    public static function provider_supports_api($provider) {
        $provider_config = self::get_provider_settings($provider);
        return $provider_config && isset($provider_config['api_supported']) && $provider_config['api_supported'];
    }
    
    /**
     * Check if API is recommended for provider
     */
    public static function is_api_recommended($provider) {
        $provider_config = self::get_provider_settings($provider);
        return $provider_config && isset($provider_config['api_recommended']) && $provider_config['api_recommended'];
    }
    
    /**
     * Get encryption options
     */
    public static function get_encryption_options() {
        return array(
            'none' => __('None', 'aha-mail-smtp'),
            'ssl' => __('SSL', 'aha-mail-smtp'),
            'tls' => __('TLS/STARTTLS', 'aha-mail-smtp')
        );
    }
    
    /**
     * Get common SMTP ports
     */
    public static function get_common_ports() {
        return array(
            25 => __('25 (Default)', 'aha-mail-smtp'),
            465 => __('465 (SSL)', 'aha-mail-smtp'),
            587 => __('587 (TLS)', 'aha-mail-smtp'),
            2525 => __('2525 (Alternative)', 'aha-mail-smtp')
        );
    }
    
    /**
     * Get debug information
     */
    public static function get_debug_info() {
        $settings = self::get_all_settings();
        
        // Remove sensitive information
        $debug_settings = $settings;
        $debug_settings['smtp_password'] = !empty($settings['smtp_password']) ? '***' : '';
        $debug_settings['api_key'] = !empty($settings['api_key']) ? '***' : '';
        $debug_settings['api_secret'] = !empty($settings['api_secret']) ? '***' : '';
        $debug_settings['client_secret'] = !empty($settings['client_secret']) ? '***' : '';
        
        return array(
            'settings' => $debug_settings,
            'connection_status' => self::get_connection_status(),
            'system_info' => AHA_Mail_SMTP_Core::get_system_info()
        );
    }
    
    /**
     * Migrate settings from older versions
     */
    public static function migrate_settings($from_version, $to_version) {
        // Add migration logic here if needed in future versions
        return true;
    }
    
    /**
     * Clean up expired settings
     */
    public static function cleanup_settings() {
        // Remove any temporary or expired settings
        // This can be called during plugin deactivation or via cron
        return true;
    }
    
    /**
     * Check if SMTP is configured
     */
    public static function is_smtp_configured() {
        $settings = self::get_all_settings();
        
        // Check if connection mode is API and provider supports it
        if (!empty($settings['connection_mode']) && $settings['connection_mode'] === 'api') {
            $provider = $settings['provider'];
            if (self::provider_supports_api($provider)) {
                // For API mode, check if API credentials are set
                $api_fields = self::get_provider_api_fields($provider);
                foreach ($api_fields as $field_key => $field_config) {
                    if (empty($settings[$field_key])) {
                        return false;
                    }
                }
                return true;
            }
        }
        
        // For SMTP mode, check if host is configured
        return !empty($settings['smtp_host']);
    }
    
    /**
     * Get SMTP settings in a formatted array
     */
    public static function get_smtp_settings() {
        $settings = self::get_all_settings();
        
        return array(
            'host' => $settings['smtp_host'],
            'port' => $settings['smtp_port'],
            'encryption' => $settings['smtp_encryption'],
            'auth' => $settings['smtp_auth'],
            'username' => $settings['smtp_username'],
            'password' => $settings['smtp_password'],
            'from_email' => $settings['from_email'],
            'from_name' => $settings['from_name'],
            'force_from' => $settings['force_from'],
            'reply_to_email' => $settings['reply_to_email'],
            'return_path' => $settings['return_path']
        );
    }
}