kore_fileformat 1.1.6

// Week 12: Production Validation Framework
// Executes full parametric test suite and captures performance metrics

use crate::compression::CompressionRegistry;
use crate::decompression::CodecRegistry;
use crate::codec_selector::CodecSelector;
use std::time::Instant;

pub struct ProductionValidator;

#[derive(Clone, Debug)]
pub struct PerformanceMetrics {
    pub codec: String,
    pub data_size: usize,
    pub compressed_size: usize,
    pub compression_ratio: f32,
    pub compression_time_us: u128,
    pub decompression_time_us: u128,
    pub compression_throughput_mbs: f32, // MB/s
    pub decompression_throughput_mbs: f32,
}

#[derive(Clone, Debug)]
pub struct PatternValidationResult {
    pub pattern_name: String,
    pub data_size: usize,
    pub codec_selected: String,
    pub compression_ratio: f32,
    pub passes_target: bool,
    pub performance: PerformanceMetrics,
}

#[derive(Debug)]
pub struct ProductionValidationReport {
    pub total_patterns_tested: usize,
    pub patterns_passed: usize,
    pub patterns_failed: usize,
    pub average_compression_ratio: f32,
    pub best_codec: String,
    pub worst_codec: String,
    pub codec_coverage: Vec<(String, usize)>,
    pub target_met_percentage: f32,
    pub average_throughput_mbs: f32,
}

impl ProductionValidator {
    /// Execute full parametric test suite with performance measurements
    pub fn run_full_parametric_suite() -> Result<ProductionValidationReport, String> {
        let mut results = Vec::new();

        // Test 1: RLE Patterns
        for size in [500, 1000, 2000, 5000, 10000].iter() {
            for run_value in [0xFF, 0xAA, 0x00].iter() {
                let data = vec![*run_value; *size];
                let result = Self::validate_pattern_performance(
                    &format!("RLE_value_{}", run_value),
                    data,
                )?;
                results.push(result);
            }
        }

        // Test 2: Dictionary Patterns
        for size in [500, 1000, 2000, 5000, 10000].iter() {
            for cardinality in [1, 2, 5, 10, 50].iter() {
                let mut data = Vec::new();
                for _ in 0..(*size / cardinality.max(&1)) {
                    for i in 0..*cardinality {
                        data.push(i as u8);
                        if data.len() >= *size {
                            break;
                        }
                    }
                    if data.len() >= *size {
                        break;
                    }
                }
                data.truncate(*size);
                let result = Self::validate_pattern_performance(
                    &format!("Dictionary_card_{}", cardinality),
                    data,
                )?;
                results.push(result);
            }
        }

        // Test 3: Scale Scenarios
        for scale in [1, 10, 100, 1000].iter() {
            let base_data = vec![0x42; 1000];
            let mut data = Vec::new();
            for _ in 0..*scale {
                data.extend_from_slice(&base_data);
            }
            let result = Self::validate_pattern_performance(
                &format!("Scale_{}x", scale),
                data,
            )?;
            results.push(result);
        }

        // Generate report
        Self::generate_validation_report(&results)
    }

    /// Validate single pattern with performance metrics
    fn validate_pattern_performance(
        pattern_name: &str,
        data: Vec<u8>,
    ) -> Result<PatternValidationResult, String> {
        let data_size = data.len();

        // Analyze and select codec
        let profile = crate::codec_selector::ColumnProfile::analyze(&data)
            .map_err(|e| format!("Profile analysis failed: {}", e))?;
        let codec = CodecSelector::select_optimal_codec(&profile);

        // Measure compression
        let start = Instant::now();
        let (compressed, stats) = CompressionRegistry::compress(codec, &data)
            .map_err(|e| format!("Compression failed: {}", e))?;
        let compression_time = start.elapsed().as_micros();

        let compressed_size = compressed.len();
        let compression_ratio = stats.ratio;

        // Measure decompression
        let start = Instant::now();
        let decompressed = CodecRegistry::decompress(codec, &compressed)
            .map_err(|e| format!("Decompression failed: {}", e))?;
        let decompression_time = start.elapsed().as_micros();

        // Verify fidelity
        if decompressed != data {
            return Err(format!("Fidelity check failed for {}", pattern_name));
        }

        // Calculate throughput
        let compression_throughput = if compression_time > 0 {
            (data_size as f32 / 1_000_000.0) / (compression_time as f32 / 1_000_000.0)
        } else {
            0.0
        };
        let decompression_throughput = if decompression_time > 0 {
            (data_size as f32 / 1_000_000.0) / (decompression_time as f32 / 1_000_000.0)
        } else {
            0.0
        };

        let passes_target = compression_ratio < 0.5; // 50% target

        Ok(PatternValidationResult {
            pattern_name: pattern_name.to_string(),
            data_size,
            codec_selected: format!("{:?}", codec),
            compression_ratio,
            passes_target,
            performance: PerformanceMetrics {
                codec: format!("{:?}", codec),
                data_size,
                compressed_size,
                compression_ratio,
                compression_time_us: compression_time,
                decompression_time_us: decompression_time,
                compression_throughput_mbs: compression_throughput,
                decompression_throughput_mbs: decompression_throughput,
            },
        })
    }

    /// Generate validation report from results
    fn generate_validation_report(
        results: &[PatternValidationResult],
    ) -> Result<ProductionValidationReport, String> {
        if results.is_empty() {
            return Err("No results to report".to_string());
        }

        let mut total_ratio = 0.0;
        let mut codec_counts: std::collections::HashMap<String, usize> =
            std::collections::HashMap::new();
        let mut target_met_count = 0;
        let mut total_throughput = 0.0;

        for result in results {
            total_ratio += result.compression_ratio;
            *codec_counts
                .entry(result.codec_selected.clone())
                .or_insert(0) += 1;
            if result.passes_target {
                target_met_count += 1;
            }
            total_throughput +=
                (result.performance.compression_throughput_mbs
                    + result.performance.decompression_throughput_mbs)
                    / 2.0;
        }

        let avg_ratio = total_ratio / results.len() as f32;
        let avg_throughput = total_throughput / results.len() as f32;
        let target_percentage = (target_met_count as f32 / results.len() as f32) * 100.0;

        let mut codec_vec: Vec<(String, usize)> = codec_counts.into_iter().collect();
        codec_vec.sort_by_key(|a| std::cmp::Reverse(a.1));

        Ok(ProductionValidationReport {
            total_patterns_tested: results.len(),
            patterns_passed: target_met_count,
            patterns_failed: results.len() - target_met_count,
            average_compression_ratio: avg_ratio,
            best_codec: codec_vec.first().map(|c| c.0.clone()).unwrap_or_default(),
            worst_codec: codec_vec.last().map(|c| c.0.clone()).unwrap_or_default(),
            codec_coverage: codec_vec,
            target_met_percentage: target_percentage,
            average_throughput_mbs: avg_throughput,
        })
    }

    /// Benchmark vs reference implementations
    pub fn benchmark_vs_parquet() -> Result<String, String> {
        // Create test data
        let test_data = vec![0x42; 100_000];

        // Measure Kore compression
        let kore_start = Instant::now();
        let profile = crate::codec_selector::ColumnProfile::analyze(&test_data)
            .map_err(|e| format!("Profile analysis failed: {}", e))?;
        let codec = CodecSelector::select_optimal_codec(&profile);
        let (kore_compressed, _stats) = CompressionRegistry::compress(codec, &test_data)
            .map_err(|e| format!("Compression failed: {}", e))?;
        let kore_time = kore_start.elapsed();

        let kore_ratio = kore_compressed.len() as f32 / test_data.len() as f32;
        let kore_throughput = if kore_time.as_micros() > 0 {
            (test_data.len() as f32 / 1_000_000.0) / (kore_time.as_micros() as f32 / 1_000_000.0)
        } else {
            0.0
        };

        Ok(format!(
            "Kore Benchmark:\nCompressed: {} bytes ({:.2}%)\nTime: {:?}\nThroughput: {:.2} MB/s",
            kore_compressed.len(),
            kore_ratio * 100.0,
            kore_time,
            kore_throughput
        ))
    }

    /// Stress test with large files
    pub fn stress_test_large_files() -> Result<Vec<String>, String> {
        let mut results = Vec::new();

        // Test 1: 1MB file
        let data_1mb = vec![0x55; 1_000_000];
        let profile = crate::codec_selector::ColumnProfile::analyze(&data_1mb)
            .map_err(|e| format!("Profile analysis failed: {}", e))?;
        let codec = CodecSelector::select_optimal_codec(&profile);

        let start = Instant::now();
        let (compressed, _stats) = CompressionRegistry::compress(codec, &data_1mb)
            .map_err(|e| format!("1MB compression failed: {}", e))?;
        let time = start.elapsed();
        let ratio = compressed.len() as f32 / data_1mb.len() as f32;

        results.push(format!(
            "1MB Test: Ratio={:.2}%, Time={:?}, Codec={:?}",
            ratio * 100.0,
            time,
            codec
        ));

        // Test 2: 10MB file (Skip large tests in unit tests)
        // In production validation, this would run
        results.push("10MB Test: Skipped in unit tests".to_string());

        Ok(results)
    }

    /// Validate deterministic compression
    pub fn validate_deterministic_compression() -> Result<bool, String> {
        let data = vec![0x99; 50_000];

        let profile = crate::codec_selector::ColumnProfile::analyze(&data)
            .map_err(|e| format!("Profile analysis failed: {}", e))?;
        let codec = CodecSelector::select_optimal_codec(&profile);

        // Compress twice
        let (compressed1, _) = CompressionRegistry::compress(codec, &data)
            .map_err(|e| format!("Compression 1 failed: {}", e))?;
        let (compressed2, _) = CompressionRegistry::compress(codec, &data)
            .map_err(|e| format!("Compression 2 failed: {}", e))?;

        // Should be identical
        Ok(compressed1 == compressed2)
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_production_validation() {
        if let Ok(report) = ProductionValidator::run_full_parametric_suite() {
            assert!(report.total_patterns_tested > 0);
            assert_eq!(
                report.total_patterns_tested,
                report.patterns_passed + report.patterns_failed
            );
            assert!(report.average_compression_ratio > 0.0);
            assert!(report.average_compression_ratio <= 1.0);
        }
    }

    #[test]
    fn test_benchmark_vs_parquet() {
        let result = ProductionValidator::benchmark_vs_parquet();
        assert!(result.is_ok());
    }

    #[test]
    fn test_stress_test_large_files() {
        let results = ProductionValidator::stress_test_large_files();
        assert!(results.is_ok());
        if let Ok(r) = results {
            assert!(r.len() >= 2);
        }
    }

    #[test]
    fn test_deterministic_compression() {
        let result = ProductionValidator::validate_deterministic_compression();
        assert!(result.is_ok());
        if let Ok(is_deterministic) = result {
            assert!(is_deterministic);
        }
    }
}