<?php
/**
 * Cargador de Variables de Entorno
 * Sistema de Inventario Forestal de Guatemala
 */

class Environment {
    private static $loaded = false;
    private static $variables = [];
    
    /**
     * Cargar variables de entorno desde archivo .env
     */
    public static function load($envFile = null) {
        if (self::$loaded) {
            return;
        }
        
        // Determinar archivo de entorno
        if ($envFile === null) {
            $rootDir = dirname(dirname(__DIR__));
            
            // Prioridad: .env.production > .env.development > .env
            $envFiles = [
                $rootDir . '/.env.production',
                $rootDir . '/.env.development',
                $rootDir . '/.env'
            ];
            
            foreach ($envFiles as $file) {
                if (file_exists($file)) {
                    $envFile = $file;
                    break;
                }
            }
        }
        
        if (!$envFile || !file_exists($envFile)) {
            // Si no hay archivo .env, usar valores por defecto
            self::setDefaults();
            self::$loaded = true;
            return;
        }
        
        // Leer archivo .env
        $lines = file($envFile, FILE_IGNORE_NEW_LINES | FILE_SKIP_EMPTY_LINES);
        
        foreach ($lines as $line) {
            // Ignorar comentarios
            if (strpos(trim($line), '#') === 0) {
                continue;
            }
            
            // Parsear línea
            if (strpos($line, '=') !== false) {
                list($key, $value) = explode('=', $line, 2);
                $key = trim($key);
                $value = trim($value);
                
                // Remover comillas si existen
                if (preg_match('/^"(.*)"$/', $value, $matches)) {
                    $value = $matches[1];
                } elseif (preg_match("/^'(.*)'$/", $value, $matches)) {
                    $value = $matches[1];
                }
                
                // Establecer variable de entorno
                self::$variables[$key] = $value;
                
                // También establecer en $_ENV y putenv para compatibilidad
                $_ENV[$key] = $value;
                putenv("$key=$value");
            }
        }
        
        self::$loaded = true;
    }
    
    /**
     * Obtener variable de entorno
     */
    public static function get($key, $default = null) {
        self::load();
        
        // Prioridad: variables cargadas > $_ENV > getenv() > default
        if (isset(self::$variables[$key])) {
            return self::parseValue(self::$variables[$key]);
        }
        
        if (isset($_ENV[$key])) {
            return self::parseValue($_ENV[$key]);
        }
        
        $value = getenv($key);
        if ($value !== false) {
            return self::parseValue($value);
        }
        
        return $default;
    }
    
    /**
     * Verificar si una variable existe
     */
    public static function has($key) {
        self::load();
        return isset(self::$variables[$key]) || isset($_ENV[$key]) || getenv($key) !== false;
    }
    
    /**
     * Obtener todas las variables
     */
    public static function all() {
        self::load();
        return array_merge($_ENV, self::$variables);
    }
    
    /**
     * Parsear valor para convertir strings a tipos apropiados
     */
    private static function parseValue($value) {
        // Convertir strings booleanos
        if (strtolower($value) === 'true') {
            return true;
        }
        if (strtolower($value) === 'false') {
            return false;
        }
        
        // Convertir null
        if (strtolower($value) === 'null') {
            return null;
        }
        
        // Convertir números
        if (is_numeric($value)) {
            return strpos($value, '.') !== false ? (float)$value : (int)$value;
        }
        
        return $value;
    }
    
    /**
     * Establecer valores por defecto
     */
    private static function setDefaults() {
        $defaults = [
            // Base de datos
            'DB_HOST' => 'localhost',
            'DB_NAME' => 'sif_gt',
            'DB_USER' => 'root',
            'DB_PASS' => '',
            'DB_PORT' => 3306,
            'DB_CHARSET' => 'utf8mb4',
            
            // Aplicación
            'APP_NAME' => 'Sistema de Inventario Forestal Guatemala',
            'APP_VERSION' => '1.0.0',
            'APP_ENV' => 'development',
            'APP_DEBUG' => true,
            'APP_URL' => 'http://localhost',
            'APP_TIMEZONE' => 'America/Guatemala',
            
            // Seguridad
            'JWT_SECRET' => 'default_jwt_secret_change_in_production',
            'JWT_EXPIRATION' => 86400,
            'ENCRYPTION_KEY' => 'default_encryption_key_32_chars_long',
            
            // Archivos
            'UPLOAD_DIR' => 'uploads',
            'MAX_FILE_SIZE' => 10485760,
            'ALLOWED_FILE_TYPES' => 'pdf',
            
            // Logs
            'LOG_LEVEL' => 'debug',
            'LOG_DIR' => 'logs',
            
            // Cache
            'CACHE_ENABLED' => true,
            'CACHE_DIR' => 'cache',
            'CACHE_TTL' => 3600,
            
            // API
            'API_RATE_LIMIT' => 1000,
            'API_TIMEOUT' => 30,
            
            // CORS
            'CORS_ALLOWED_ORIGINS' => '*',
            'CORS_ALLOWED_METHODS' => 'GET,POST,PUT,DELETE,OPTIONS',
            'CORS_ALLOWED_HEADERS' => 'Content-Type,Authorization,X-Requested-With',
            
            // Sesiones
            'SESSION_LIFETIME' => 86400,
            'SESSION_SECURE' => false,
            'SESSION_HTTP_ONLY' => true,
            'SESSION_SAME_SITE' => 'strict',
            
            // Monitoreo
            'MONITORING_ENABLED' => false,
            'MONITORING_INTERVAL' => 900,
            
            // Backup
            'BACKUP_DIR' => 'backups',
            'MAX_BACKUPS' => 30,
            'BACKUP_COMPRESSION' => true,
            
            // Performance
            'OPCACHE_ENABLED' => false,
            'GZIP_COMPRESSION' => true,
            
            // Seguridad
            'SECURITY_MAX_LOGIN_ATTEMPTS' => 5,
            'SECURITY_LOCKOUT_DURATION' => 1800,
            
            // Mantenimiento
            'MAINTENANCE_MODE' => false,
            
            // SSL
            'FORCE_HTTPS' => false,
            
            // Notificaciones
            'NOTIFICATIONS_ENABLED' => false,
            
            // GPS
            'GPS_ACCURACY_THRESHOLD' => 10,
            'GPS_TIMEOUT' => 30000,
            'GPS_HIGH_ACCURACY' => true,
            
            // Sincronización
            'SYNC_BATCH_SIZE' => 100,
            'SYNC_TIMEOUT' => 60,
            'SYNC_RETRY_ATTEMPTS' => 3,
            
            // PWA
            'PWA_CACHE_VERSION' => '1.0.0',
            'PWA_OFFLINE_PAGES' => true,
            'PWA_BACKGROUND_SYNC' => true
        ];
        
        foreach ($defaults as $key => $value) {
            self::$variables[$key] = $value;
            $_ENV[$key] = $value;
            putenv("$key=$value");
        }
    }
    
    /**
     * Validar configuración crítica
     */
    public static function validate() {
        $errors = [];
        
        // Validar configuración de base de datos
        if (!self::get('DB_HOST')) {
            $errors[] = 'DB_HOST es requerido';
        }
        if (!self::get('DB_NAME')) {
            $errors[] = 'DB_NAME es requerido';
        }
        if (!self::get('DB_USER')) {
            $errors[] = 'DB_USER es requerido';
        }
        
        // Validar configuración de seguridad
        if (self::get('APP_ENV') === 'production') {
            if (self::get('JWT_SECRET') === 'default_jwt_secret_change_in_production') {
                $errors[] = 'JWT_SECRET debe cambiarse en producción';
            }
            if (self::get('ENCRYPTION_KEY') === 'default_encryption_key_32_chars_long') {
                $errors[] = 'ENCRYPTION_KEY debe cambiarse en producción';
            }
            if (!self::get('FORCE_HTTPS')) {
                $errors[] = 'FORCE_HTTPS debe estar habilitado en producción';
            }
        }
        
        // Validar directorios
        $dirs = ['UPLOAD_DIR', 'LOG_DIR', 'CACHE_DIR', 'BACKUP_DIR'];
        foreach ($dirs as $dir) {
            $path = self::get($dir);
            if ($path && !is_dir($path)) {
                $errors[] = "Directorio {$dir} no existe: {$path}";
            }
        }
        
        return $errors;
    }
    
    /**
     * Obtener configuración para mostrar (sin datos sensibles)
     */
    public static function getSafeConfig() {
        $config = self::all();
        
        // Remover datos sensibles
        $sensitive = [
            'DB_PASS', 'JWT_SECRET', 'ENCRYPTION_KEY', 'PASSWORD_SALT',
            'MAIL_PASSWORD', 'WEBHOOK_SECRET', 'REDIS_PASSWORD',
            'REMOTE_BACKUP_PASS', 'HEALTH_CHECK_TOKEN'
        ];
        
        foreach ($sensitive as $key) {
            if (isset($config[$key])) {
                $config[$key] = '***HIDDEN***';
            }
        }
        
        return $config;
    }
    
    /**
     * Generar archivo .env de ejemplo
     */
    public static function generateExample($outputFile = '.env.example') {
        $config = self::getSafeConfig();
        $content = "# Archivo de configuración de ejemplo\n";
        $content .= "# Copia este archivo a .env y ajusta los valores\n\n";
        
        foreach ($config as $key => $value) {
            if (is_bool($value)) {
                $value = $value ? 'true' : 'false';
            } elseif (is_null($value)) {
                $value = '';
            }
            
            $content .= "{$key}={$value}\n";
        }
        
        file_put_contents($outputFile, $content);
        return $outputFile;
    }
}

// Auto-cargar al incluir este archivo
Environment::load();
?>