#!/usr/bin/env php
<?php

/**
 * Parametric BOM System Validation Script
 * 
 * This script performs comprehensive validation of the parametric BOM system
 * including parameter validation, formula calculation, condition rule evaluation,
 * and BOM resolution testing.
 * 
 * Usage: php scripts/validation/validate_bom_system.php
 */

require_once __DIR__ . '/../../bootstrap/app.php';

use App\Models\Tenant;
use App\Models\Design\DesignModel;
use App\Models\Design\ModelParameter;
use App\Models\Design\ModelFormula;
use App\Models\Design\BomConditionRule;
use App\Services\Design\ModelParameterService;
use App\Services\Design\ModelFormulaService;
use App\Services\Design\BomConditionRuleService;
use App\Services\Design\BomResolverService;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Log;

class BomSystemValidator
{
    private array $results = [];
    private int $passedTests = 0;
    private int $failedTests = 0;
    private int $totalTests = 0;
    
    public function __construct()
    {
        $this->output("\n=== Parametric BOM System Validation ===");
        $this->output("Starting comprehensive system validation...\n");
    }

    public function run(): void
    {
        try {
            // Test database connectivity
            $this->testDatabaseConnectivity();
            
            // Test basic model operations
            $this->testModelOperations();
            
            // Test parameter validation
            $this->testParameterValidation();
            
            // Test formula calculations
            $this->testFormulaCalculations();
            
            // Test condition rule evaluation
            $this->testConditionRuleEvaluation();
            
            // Test BOM resolution
            $this->testBomResolution();
            
            // Test performance benchmarks
            $this->testPerformanceBenchmarks();
            
            // Test error handling
            $this->testErrorHandling();
            
            // Generate final report
            $this->generateReport();
            
        } catch (Exception $e) {
            $this->output("\n❌ Critical Error: " . $e->getMessage());
            $this->output("Stack trace: " . $e->getTraceAsString());
            exit(1);
        }
    }

    private function testDatabaseConnectivity(): void
    {
        $this->output("\n🔍 Testing Database Connectivity...");
        
        $this->test('Database connection', function() {
            return DB::connection()->getPdo() !== null;
        });
        
        $this->test('Tenant table access', function() {
            return Tenant::query()->exists();
        });
        
        $this->test('Design models table access', function() {
            return DesignModel::query()->exists();
        });
    }

    private function testModelOperations(): void
    {
        $this->output("\n🔍 Testing Model Operations...");
        
        // Find test tenant and model
        $tenant = Tenant::where('code', 'KSS_DEMO')->first();
        if (!$tenant) {
            $this->test('KSS_DEMO tenant exists', function() { return false; });
            $this->output("   ⚠️  Please run KSS01ModelSeeder first");
            return;
        }
        
        $model = DesignModel::where('tenant_id', $tenant->id)
                           ->where('code', 'KSS01')
                           ->first();
        
        $this->test('KSS01 model exists', function() use ($model) {
            return $model !== null;
        });
        
        if (!$model) {
            $this->output("   ⚠️  Please run KSS01ModelSeeder first");
            return;
        }
        
        $this->test('Model has parameters', function() use ($model) {
            return $model->parameters()->count() > 0;
        });
        
        $this->test('Model has formulas', function() use ($model) {
            return ModelFormula::where('model_id', $model->id)->count() > 0;
        });
        
        $this->test('Model has condition rules', function() use ($model) {
            return BomConditionRule::where('model_id', $model->id)->count() > 0;
        });
    }

    private function testParameterValidation(): void
    {
        $this->output("\n🔍 Testing Parameter Validation...");
        
        $tenant = Tenant::where('code', 'KSS_DEMO')->first();
        $model = DesignModel::where('tenant_id', $tenant->id)->where('code', 'KSS01')->first();
        
        if (!$model) {
            $this->output("   ⚠️  Skipping parameter tests - no KSS01 model");
            return;
        }
        
        $parameterService = new ModelParameterService();
        $parameterService->setTenantId($tenant->id);
        $parameterService->setApiUserId(1);
        
        // Test valid parameters
        $this->test('Valid parameters accepted', function() use ($parameterService, $model) {
            $validParams = [
                'W0' => 1200,
                'H0' => 800,
                'screen_type' => 'FABRIC',
                'install_type' => 'WALL'
            ];
            
            try {
                $result = $parameterService->validateParameters($model->id, $validParams);
                return is_array($result) && count($result) > 0;
            } catch (Exception $e) {
                $this->output("     Error: " . $e->getMessage());
                return false;
            }
        });
        
        // Test parameter range validation
        $this->test('Parameter range validation', function() use ($parameterService, $model) {
            $invalidParams = [
                'W0' => 5000,  // Above max
                'H0' => 800,
                'screen_type' => 'FABRIC',
                'install_type' => 'WALL'
            ];
            
            try {
                $parameterService->validateParameters($model->id, $invalidParams);
                return false;  // Should have thrown exception
            } catch (Exception $e) {
                return true;   // Expected exception
            }
        });
        
        // Test required parameter validation
        $this->test('Required parameter validation', function() use ($parameterService, $model) {
            $incompleteParams = [
                'W0' => 1200,
                // Missing H0
                'screen_type' => 'FABRIC'
            ];
            
            try {
                $parameterService->validateParameters($model->id, $incompleteParams);
                return false;  // Should have thrown exception
            } catch (Exception $e) {
                return true;   // Expected exception
            }
        });
    }

    private function testFormulaCalculations(): void
    {
        $this->output("\n🔍 Testing Formula Calculations...");
        
        $tenant = Tenant::where('code', 'KSS_DEMO')->first();
        $model = DesignModel::where('tenant_id', $tenant->id)->where('code', 'KSS01')->first();
        
        if (!$model) {
            $this->output("   ⚠️  Skipping formula tests - no KSS01 model");
            return;
        }
        
        $formulaService = new ModelFormulaService();
        $formulaService->setTenantId($tenant->id);
        $formulaService->setApiUserId(1);
        
        $testParams = [
            'W0' => 1200,
            'H0' => 800,
            'screen_type' => 'FABRIC',
            'install_type' => 'WALL'
        ];
        
        $this->test('Basic formula calculations', function() use ($formulaService, $model, $testParams) {
            try {
                $results = $formulaService->calculateFormulas($model->id, $testParams);
                
                // Check expected calculated values
                return isset($results['W1']) && $results['W1'] == 1300 &&  // 1200 + 100
                       isset($results['H1']) && $results['H1'] == 900 &&   // 800 + 100
                       isset($results['area']) && abs($results['area'] - 1.17) < 0.01; // (1300*900)/1000000
            } catch (Exception $e) {
                $this->output("     Error: " . $e->getMessage());
                return false;
            }
        });
        
        $this->test('Formula dependency resolution', function() use ($formulaService, $model, $testParams) {
            try {
                $results = $formulaService->calculateFormulas($model->id, $testParams);
                
                // Ensure dependent formulas are calculated in correct order
                return isset($results['W1']) && isset($results['H1']) && isset($results['area']);
            } catch (Exception $e) {
                return false;
            }
        });
        
        // Test circular dependency detection
        $this->test('Circular dependency detection', function() use ($formulaService, $model) {
            // This would require creating circular formulas, skipping for now
            return true;
        });
    }

    private function testConditionRuleEvaluation(): void
    {
        $this->output("\n🔍 Testing Condition Rule Evaluation...");
        
        $tenant = Tenant::where('code', 'KSS_DEMO')->first();
        $model = DesignModel::where('tenant_id', $tenant->id)->where('code', 'KSS01')->first();
        
        if (!$model) {
            $this->output("   ⚠️  Skipping rule tests - no KSS01 model");
            return;
        }
        
        $ruleService = new BomConditionRuleService();
        $ruleService->setTenantId($tenant->id);
        $ruleService->setApiUserId(1);
        
        $calculatedValues = [
            'W0' => 1200,
            'H0' => 800,
            'W1' => 1300,
            'H1' => 900,
            'area' => 1.17,
            'screen_type' => 'FABRIC',
            'install_type' => 'WALL'
        ];
        
        $this->test('Basic rule evaluation', function() use ($ruleService, $model, $calculatedValues) {
            try {
                $results = $ruleService->evaluateRules($model->id, $calculatedValues);
                return isset($results['matched_rules']) && is_array($results['matched_rules']);
            } catch (Exception $e) {
                $this->output("     Error: " . $e->getMessage());
                return false;
            }
        });
        
        $this->test('Rule action generation', function() use ($ruleService, $model, $calculatedValues) {
            try {
                $results = $ruleService->evaluateRules($model->id, $calculatedValues);
                return isset($results['bom_actions']) && is_array($results['bom_actions']);
            } catch (Exception $e) {
                return false;
            }
        });
        
        // Test different parameter scenarios
        $steelParams = array_merge($calculatedValues, ['screen_type' => 'STEEL']);
        $this->test('Material type rule evaluation', function() use ($ruleService, $model, $steelParams) {
            try {
                $results = $ruleService->evaluateRules($model->id, $steelParams);
                $matchedRules = collect($results['matched_rules']);
                return $matchedRules->contains(function($rule) {
                    return strpos($rule['rule_name'], 'Steel') !== false;
                });
            } catch (Exception $e) {
                return false;
            }
        });
    }

    private function testBomResolution(): void
    {
        $this->output("\n🔍 Testing BOM Resolution...");
        
        $tenant = Tenant::where('code', 'KSS_DEMO')->first();
        $model = DesignModel::where('tenant_id', $tenant->id)->where('code', 'KSS01')->first();
        
        if (!$model) {
            $this->output("   ⚠️  Skipping BOM tests - no KSS01 model");
            return;
        }
        
        $bomResolver = new BomResolverService(
            new ModelParameterService(),
            new ModelFormulaService(),
            new BomConditionRuleService()
        );
        $bomResolver->setTenantId($tenant->id);
        $bomResolver->setApiUserId(1);
        
        $inputParams = [
            'W0' => 1200,
            'H0' => 800,
            'screen_type' => 'FABRIC',
            'install_type' => 'WALL'
        ];
        
        $this->test('Complete BOM resolution', function() use ($bomResolver, $model, $inputParams) {
            try {
                $result = $bomResolver->resolveBom($model->id, $inputParams);
                
                return isset($result['model']) &&
                       isset($result['input_parameters']) &&
                       isset($result['calculated_values']) &&
                       isset($result['resolved_bom']) &&
                       is_array($result['resolved_bom']);
            } catch (Exception $e) {
                $this->output("     Error: " . $e->getMessage());
                return false;
            }
        });
        
        $this->test('BOM items have required fields', function() use ($bomResolver, $model, $inputParams) {
            try {
                $result = $bomResolver->resolveBom($model->id, $inputParams);
                
                if (empty($result['resolved_bom'])) {
                    return true; // Empty BOM is valid
                }
                
                foreach ($result['resolved_bom'] as $item) {
                    if (!isset($item['target_type']) || !isset($item['target_id']) || !isset($item['quantity'])) {
                        return false;
                    }
                }
                return true;
            } catch (Exception $e) {
                return false;
            }
        });
        
        $this->test('BOM preview functionality', function() use ($bomResolver, $model, $inputParams) {
            try {
                $result = $bomResolver->previewBom($model->id, $inputParams);
                return isset($result['resolved_bom']);
            } catch (Exception $e) {
                return false;
            }
        });
        
        $this->test('BOM comparison functionality', function() use ($bomResolver, $model) {
            try {
                $params1 = ['W0' => 800, 'H0' => 600, 'screen_type' => 'FABRIC', 'install_type' => 'WALL'];
                $params2 = ['W0' => 1200, 'H0' => 800, 'screen_type' => 'STEEL', 'install_type' => 'CEILING'];
                
                $result = $bomResolver->compareBomByParameters($model->id, $params1, $params2);
                
                return isset($result['parameters_diff']) &&
                       isset($result['bom_diff']) &&
                       isset($result['bom_diff']['added']) &&
                       isset($result['bom_diff']['removed']);
            } catch (Exception $e) {
                return false;
            }
        });
    }

    private function testPerformanceBenchmarks(): void
    {
        $this->output("\n🔍 Testing Performance Benchmarks...");
        
        $tenant = Tenant::where('code', 'KSS_DEMO')->first();
        $model = DesignModel::where('tenant_id', $tenant->id)->where('code', 'KSS01')->first();
        
        if (!$model) {
            $this->output("   ⚠️  Skipping performance tests - no KSS01 model");
            return;
        }
        
        $bomResolver = new BomResolverService(
            new ModelParameterService(),
            new ModelFormulaService(),
            new BomConditionRuleService()
        );
        $bomResolver->setTenantId($tenant->id);
        $bomResolver->setApiUserId(1);
        
        // Test single BOM resolution performance
        $this->test('Single BOM resolution performance (<500ms)', function() use ($bomResolver, $model) {
            $inputParams = [
                'W0' => 1200,
                'H0' => 800,
                'screen_type' => 'FABRIC',
                'install_type' => 'WALL'
            ];
            
            $startTime = microtime(true);
            try {
                $bomResolver->resolveBom($model->id, $inputParams);
                $duration = (microtime(true) - $startTime) * 1000;
                $this->output("     Duration: {$duration}ms");
                return $duration < 500;
            } catch (Exception $e) {
                return false;
            }
        });
        
        // Test multiple BOM resolutions
        $this->test('Multiple BOM resolutions performance (10 iterations <2s)', function() use ($bomResolver, $model) {
            $scenarios = [
                ['W0' => 800, 'H0' => 600, 'screen_type' => 'FABRIC', 'install_type' => 'WALL'],
                ['W0' => 1200, 'H0' => 800, 'screen_type' => 'STEEL', 'install_type' => 'CEILING'],
                ['W0' => 1500, 'H0' => 1000, 'screen_type' => 'FABRIC', 'install_type' => 'RECESSED'],
                ['W0' => 2000, 'H0' => 1200, 'screen_type' => 'STEEL', 'install_type' => 'WALL'],
                ['W0' => 900, 'H0' => 700, 'screen_type' => 'FABRIC', 'install_type' => 'CEILING']
            ];
            
            $startTime = microtime(true);
            try {
                for ($i = 0; $i < 10; $i++) {
                    foreach ($scenarios as $params) {
                        $bomResolver->resolveBom($model->id, $params);
                    }
                }
                $duration = (microtime(true) - $startTime) * 1000;
                $this->output("     Duration: {$duration}ms");
                return $duration < 2000;
            } catch (Exception $e) {
                return false;
            }
        });
    }

    private function testErrorHandling(): void
    {
        $this->output("\n🔍 Testing Error Handling...");
        
        $tenant = Tenant::where('code', 'KSS_DEMO')->first();
        
        $bomResolver = new BomResolverService(
            new ModelParameterService(),
            new ModelFormulaService(),
            new BomConditionRuleService()
        );
        $bomResolver->setTenantId($tenant->id);
        $bomResolver->setApiUserId(1);
        
        $this->test('Non-existent model handling', function() use ($bomResolver) {
            try {
                $bomResolver->resolveBom(99999, ['W0' => 1000, 'H0' => 800]);
                return false; // Should have thrown exception
            } catch (Exception $e) {
                return true;  // Expected exception
            }
        });
        
        $this->test('Invalid parameters handling', function() use ($bomResolver, $tenant) {
            $model = DesignModel::where('tenant_id', $tenant->id)->where('code', 'KSS01')->first();
            if (!$model) return true;
            
            try {
                $bomResolver->resolveBom($model->id, ['invalid_param' => 'invalid_value']);
                return false; // Should have thrown exception
            } catch (Exception $e) {
                return true;  // Expected exception
            }
        });
    }

    private function test(string $name, callable $testFunction): void
    {
        $this->totalTests++;
        
        try {
            $result = $testFunction();
            if ($result) {
                $this->passedTests++;
                $this->output("   ✅ {$name}");
                $this->results[] = ['test' => $name, 'status' => 'PASS'];
            } else {
                $this->failedTests++;
                $this->output("   ❌ {$name}");
                $this->results[] = ['test' => $name, 'status' => 'FAIL'];
            }
        } catch (Exception $e) {
            $this->failedTests++;
            $this->output("   ❌ {$name} - Exception: {$e->getMessage()}");
            $this->results[] = ['test' => $name, 'status' => 'ERROR', 'error' => $e->getMessage()];
        }
    }

    private function output(string $message): void
    {
        echo $message . "\n";
        Log::info("BOM Validation: " . $message);
    }

    private function generateReport(): void
    {
        $this->output("\n" . str_repeat("=", 60));
        $this->output("VALIDATION REPORT");
        $this->output(str_repeat("=", 60));
        
        $successRate = $this->totalTests > 0 ? round(($this->passedTests / $this->totalTests) * 100, 1) : 0;
        
        $this->output("Total Tests: {$this->totalTests}");
        $this->output("Passed: {$this->passedTests}");
        $this->output("Failed: {$this->failedTests}");
        $this->output("Success Rate: {$successRate}%");
        
        if ($this->failedTests > 0) {
            $this->output("\n❌ FAILED TESTS:");
            foreach ($this->results as $result) {
                if ($result['status'] !== 'PASS') {
                    $error = isset($result['error']) ? " - {$result['error']}" : '';
                    $this->output("   • {$result['test']}{$error}");
                }
            }
        }
        
        $this->output("\n" . str_repeat("=", 60));
        
        if ($successRate >= 90) {
            $this->output("🎉 VALIDATION PASSED - System is ready for production");
            exit(0);
        } elseif ($successRate >= 75) {
            $this->output("⚠️  VALIDATION WARNING - Some issues found, review required");
            exit(1);
        } else {
            $this->output("❌ VALIDATION FAILED - Critical issues found, system not ready");
            exit(2);
        }
    }
}

// Run the validation
$validator = new BomSystemValidator();
$validator->run();