<?php
/**
 * Validador de Archivos de Datos Iniciales
 * Sistema de Inventario Forestal de Guatemala V1.0
 * 
 * Este script valida que todos los archivos necesarios para la población
 * de datos iniciales estén presentes y tengan el contenido correcto
 */

class InitialDataFilesValidator {
    private $requiredFiles = [];
    private $passed = 0;
    private $failed = 0;
    
    public function __construct() {
        $this->requiredFiles = [
            'database/populate_initial_data.php' => [
                'description' => 'Script principal de población de datos',
                'required_content' => [
                    'class InitialDataPopulator',
                    'populateSpecies()',
                    'populateConfiguration()',
                    'populateTestData()',
                    'validateDataIntegrity()'
                ]
            ],
            'database/migrations.php' => [
                'description' => 'Sistema de migración de base de datos',
                'required_content' => [
                    'class DatabaseMigration',
                    'migrate(',
                    'rollback(',
                    'getCurrentVersion()'
                ]
            ],
            'database/especies_guatemala.sql' => [
                'description' => 'Catálogo de especies forestales de Guatemala',
                'required_content' => [
                    'Pinus maximinoi',
                    'Cupressus lusitanica',
                    'Cedrela odorata',
                    'Swietenia macrophylla',
                    'INSERT INTO especies'
                ]
            ],
            'test_initial_data.php' => [
                'description' => 'Script de validación de datos iniciales',
                'required_content' => [
                    'class InitialDataTester',
                    'testSpeciesData()',
                    'testConfigurationData()',
                    'testDataIntegrity()'
                ]
            ],
            'INITIAL_DATA_SETUP.md' => [
                'description' => 'Documentación de configuración de datos iniciales',
                'required_content' => [
                    '# Configuración de Datos Iniciales',
                    'populate_initial_data.php',
                    'Especies Forestales',
                    'Instrucciones de Uso'
                ]
            ]
        ];
    }
    
    /**
     * Ejecutar todas las validaciones
     */
    public function validateAll() {
        echo "=== VALIDACIÓN DE ARCHIVOS DE DATOS INICIALES ===\n\n";
        
        foreach ($this->requiredFiles as $file => $config) {
            $this->validateFile($file, $config);
        }
        
        $this->showResults();
    }
    
    /**
     * Validar un archivo específico
     */
    private function validateFile($filePath, $config) {
        echo "Validando: {$config['description']}\n";
        
        // Verificar que el archivo existe
        if (!file_exists($filePath)) {
            echo "  ❌ Archivo no encontrado: {$filePath}\n";
            $this->failed++;
            return;
        }
        
        echo "  ✅ Archivo existe: {$filePath}\n";
        
        // Leer contenido del archivo
        $content = file_get_contents($filePath);
        if ($content === false) {
            echo "  ❌ No se pudo leer el archivo: {$filePath}\n";
            $this->failed++;
            return;
        }
        
        // Verificar tamaño mínimo
        if (strlen($content) < 1000) {
            echo "  ⚠️  Archivo muy pequeño (menos de 1KB): {$filePath}\n";
        }
        
        // Verificar contenido requerido
        $contentPassed = 0;
        $contentTotal = count($config['required_content']);
        
        foreach ($config['required_content'] as $requiredText) {
            if (strpos($content, $requiredText) !== false) {
                $contentPassed++;
                echo "  ✅ Contiene: {$requiredText}\n";
            } else {
                echo "  ❌ Falta: {$requiredText}\n";
            }
        }
        
        if ($contentPassed === $contentTotal) {
            echo "  ✅ Contenido completo ({$contentPassed}/{$contentTotal})\n";
            $this->passed++;
        } else {
            echo "  ❌ Contenido incompleto ({$contentPassed}/{$contentTotal})\n";
            $this->failed++;
        }
        
        // Validaciones específicas por tipo de archivo
        $this->validateSpecificContent($filePath, $content);
        
        echo "\n";
    }
    
    /**
     * Validaciones específicas por tipo de archivo
     */
    private function validateSpecificContent($filePath, $content) {
        $filename = basename($filePath);
        
        switch ($filename) {
            case 'populate_initial_data.php':
                $this->validatePopulateScript($content);
                break;
                
            case 'especies_guatemala.sql':
                $this->validateSpeciesSQL($content);
                break;
                
            case 'migrations.php':
                $this->validateMigrationsScript($content);
                break;
                
            case 'test_initial_data.php':
                $this->validateTestScript($content);
                break;
        }
    }
    
    /**
     * Validar script de población
     */
    private function validatePopulateScript($content) {
        $checks = [
            'Especies mínimas' => preg_match('/especies.*25|20/', $content),
            'Configuraciones mínimas' => preg_match('/configuracion.*25|30/', $content),
            'Manejo de errores' => strpos($content, 'try') !== false && strpos($content, 'catch') !== false,
            'Validación de integridad' => strpos($content, 'validateDataIntegrity') !== false
        ];
        
        foreach ($checks as $check => $passed) {
            if ($passed) {
                echo "  ✅ {$check}\n";
            } else {
                echo "  ⚠️  {$check} - Verificar implementación\n";
            }
        }
    }
    
    /**
     * Validar SQL de especies
     */
    private function validateSpeciesSQL($content) {
        $speciesCount = substr_count($content, 'INSERT INTO especies');
        $guatemalanSpecies = [
            'Pinus maximinoi',
            'Cedrela odorata',
            'Swietenia macrophylla',
            'Quercus sp.',
            'Alnus acuminata'
        ];
        
        echo "  📊 Comandos INSERT encontrados: {$speciesCount}\n";
        
        $foundSpecies = 0;
        foreach ($guatemalanSpecies as $species) {
            if (strpos($content, $species) !== false) {
                $foundSpecies++;
            }
        }
        
        echo "  🌳 Especies guatemaltecas clave: {$foundSpecies}/" . count($guatemalanSpecies) . "\n";
        
        if ($foundSpecies >= 4) {
            echo "  ✅ Catálogo de especies adecuado\n";
        } else {
            echo "  ⚠️  Catálogo de especies incompleto\n";
        }
    }
    
    /**
     * Validar script de migraciones
     */
    private function validateMigrationsScript($content) {
        $features = [
            'Versionado' => strpos($content, 'version_compare') !== false,
            'Rollback' => strpos($content, 'rollback') !== false,
            'Transacciones' => strpos($content, 'beginTransaction') !== false,
            'Estado de migraciones' => strpos($content, 'status') !== false
        ];
        
        foreach ($features as $feature => $present) {
            if ($present) {
                echo "  ✅ {$feature}\n";
            } else {
                echo "  ❌ Falta: {$feature}\n";
            }
        }
    }
    
    /**
     * Validar script de pruebas
     */
    private function validateTestScript($content) {
        $testTypes = [
            'Estructura de tablas' => strpos($content, 'testTableStructure') !== false,
            'Datos de especies' => strpos($content, 'testSpeciesData') !== false,
            'Configuraciones' => strpos($content, 'testConfigurationData') !== false,
            'Integridad referencial' => strpos($content, 'testDataIntegrity') !== false,
            'Constraints' => strpos($content, 'testConstraints') !== false
        ];
        
        $testCount = 0;
        foreach ($testTypes as $test => $present) {
            if ($present) {
                echo "  ✅ {$test}\n";
                $testCount++;
            } else {
                echo "  ❌ Falta: {$test}\n";
            }
        }
        
        echo "  📋 Tipos de prueba implementados: {$testCount}/" . count($testTypes) . "\n";
    }
    
    /**
     * Mostrar resultados finales
     */
    private function showResults() {
        echo "=== RESULTADOS DE VALIDACIÓN ===\n";
        echo "Archivos validados: " . count($this->requiredFiles) . "\n";
        echo "Pasaron validación: {$this->passed}\n";
        echo "Fallaron validación: {$this->failed}\n";
        
        $percentage = count($this->requiredFiles) > 0 ? 
            round(($this->passed / count($this->requiredFiles)) * 100, 2) : 0;
        echo "Porcentaje de éxito: {$percentage}%\n";
        
        if ($this->failed === 0) {
            echo "\n🎉 ¡Todos los archivos de datos iniciales están correctamente implementados!\n";
            echo "\nPróximos pasos:\n";
            echo "1. Asegurar que MySQL esté ejecutándose\n";
            echo "2. Ejecutar: php database/populate_initial_data.php\n";
            echo "3. Validar con: php test_initial_data.php\n";
            echo "4. Revisar documentación en: INITIAL_DATA_SETUP.md\n";
        } else {
            echo "\n⚠️  Algunos archivos necesitan revisión.\n";
            echo "Revise los archivos marcados con ❌ antes de continuar.\n";
        }
        
        echo "\n=== ARCHIVOS CREADOS ===\n";
        foreach ($this->requiredFiles as $file => $config) {
            $status = file_exists($file) ? '✅' : '❌';
            $size = file_exists($file) ? $this->formatBytes(filesize($file)) : 'N/A';
            echo "{$status} {$file} ({$size}) - {$config['description']}\n";
        }
    }
    
    /**
     * Formatear bytes en formato legible
     */
    private function formatBytes($size, $precision = 2) {
        $units = ['B', 'KB', 'MB', 'GB'];
        
        for ($i = 0; $size > 1024 && $i < count($units) - 1; $i++) {
            $size /= 1024;
        }
        
        return round($size, $precision) . ' ' . $units[$i];
    }
    
    /**
     * Generar reporte detallado
     */
    public function generateReport() {
        $report = "# Reporte de Validación de Archivos de Datos Iniciales\n\n";
        $report .= "Generado el: " . date('Y-m-d H:i:s') . "\n\n";
        
        $report .= "## Archivos Validados\n\n";
        foreach ($this->requiredFiles as $file => $config) {
            $exists = file_exists($file);
            $status = $exists ? '✅ Existe' : '❌ Faltante';
            $size = $exists ? $this->formatBytes(filesize($file)) : 'N/A';
            
            $report .= "### {$file}\n";
            $report .= "- **Estado**: {$status}\n";
            $report .= "- **Tamaño**: {$size}\n";
            $report .= "- **Descripción**: {$config['description']}\n\n";
        }
        
        $report .= "## Resumen\n";
        $report .= "- Total de archivos: " . count($this->requiredFiles) . "\n";
        $report .= "- Archivos válidos: {$this->passed}\n";
        $report .= "- Archivos con problemas: {$this->failed}\n";
        
        file_put_contents('validation_report.md', $report);
        echo "\n📄 Reporte detallado guardado en: validation_report.md\n";
    }
}

// Ejecutar si se llama directamente
if (basename(__FILE__) == basename($_SERVER['SCRIPT_NAME'])) {
    $validator = new InitialDataFilesValidator();
    $validator->validateAll();
    $validator->generateReport();
}
?>