scirs2_stats/

performance_benchmark_suite.rs

//! advanced Enhanced Benchmark Suite
//!
//! This module provides next-generation benchmarking capabilities with intelligent
//! performance analysis, predictive modeling, automated optimization recommendations,
//! and comprehensive cross-platform performance validation for production deployment.

#![allow(dead_code)]

use crate::benchmark_suite::{BenchmarkConfig, BenchmarkMetrics};
use crate::error::{StatsError, StatsResult};
// use crate::advanced_error_enhancements_v2::CompatibilityImpact; // Commented out temporarily
use scirs2_core::ndarray::Array1;
use scirs2_core::random::{Distribution, Exponential, LogNormal, Normal, Pareto, Uniform};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::time::{Duration, Instant};

/// Compatibility impact levels (local definition)
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum CompatibilityImpact {
    None,
    Minor,
    Moderate,
    Major,
    Breaking,
}

/// advanced Benchmark Configuration with Advanced Analytics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdvancedBenchmarkConfig {
    /// Base benchmark configuration
    pub base_config: BenchmarkConfig,
    /// Enable predictive performance modeling
    pub enable_predictive_modeling: bool,
    /// Enable cross-platform validation
    pub enable_cross_platform: bool,
    /// Enable numerical stability testing
    pub enable_stability_testing: bool,
    /// Enable scalability analysis
    pub enable_scalability_analysis: bool,
    /// Enable algorithmic complexity analysis
    pub enable_complexity_analysis: bool,
    /// Enable power consumption analysis
    pub enable_power_analysis: bool,
    /// Target platforms for cross-platform testing
    pub target_platforms: Vec<TargetPlatform>,
    /// Data distribution types to test
    pub data_distributions: Vec<DataDistribution>,
    /// Precision levels to test
    pub precision_levels: Vec<PrecisionLevel>,
    /// Stress test configurations
    pub stress_test_configs: Vec<StressTestConfig>,
}

/// Target platform specification
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TargetPlatform {
    pub name: String,
    pub architecture: String,
    pub cpu_features: Vec<String>,
    pub memory_hierarchy: MemoryHierarchy,
    pub expected_performance: Option<ExpectedPerformance>,
}

/// Memory hierarchy specification
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryHierarchy {
    pub l1_cache_kb: usize,
    pub l2_cache_kb: usize,
    pub l3_cache_mb: usize,
    pub memory_bandwidth_gbps: f64,
    pub numa_nodes: usize,
}

/// Expected performance baseline
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ExpectedPerformance {
    pub operations_per_second: f64,
    pub memory_bandwidth_utilization: f64,
    pub cache_efficiency: f64,
}

/// Data distribution types for testing
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum DataDistribution {
    Uniform,
    Normal,
    LogNormal,
    Exponential,
    Pareto,
    Bimodal,
    Sparse(f64),     // sparsity ratio
    Correlated(f64), // correlation coefficient
    Outliers(f64),   // outlier percentage
}

/// Precision levels for numerical testing
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PrecisionLevel {
    Half,     // f16
    Single,   // f32
    Double,   // f64
    Extended, // f128 if available
}

/// Stress test configuration
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StressTestConfig {
    pub name: String,
    pub datasize_multiplier: f64,
    pub concurrent_operations: usize,
    pub memory_pressure: f64, // 0.0 to 1.0
    pub thermal_stress: bool,
    pub duration_minutes: f64,
}

/// Enhanced benchmark metrics with advanced analytics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdvancedBenchmarkMetrics {
    /// Base metrics
    pub base_metrics: BenchmarkMetrics,
    /// Numerical stability metrics
    pub stability_metrics: NumericalStabilityMetrics,
    /// Scalability analysis
    pub scalability_metrics: ScalabilityMetrics,
    /// Power consumption metrics
    pub power_metrics: Option<PowerMetrics>,
    /// Memory hierarchy utilization
    pub memory_hierarchy_metrics: MemoryHierarchyMetrics,
    /// Cross-platform performance variance
    pub platform_variance: Option<PlatformVarianceMetrics>,
    /// Predictive model accuracy
    pub prediction_accuracy: Option<PredictionAccuracyMetrics>,
}

/// Numerical stability analysis metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct NumericalStabilityMetrics {
    /// Relative error compared to high-precision reference
    pub relative_error: f64,
    /// Condition number analysis
    pub condition_number: Option<f64>,
    /// Error accumulation rate
    pub error_accumulation_rate: f64,
    /// Precision loss percentage
    pub precision_loss_percent: f64,
    /// Stability across different data distributions
    pub distribution_stability: HashMap<String, f64>,
}

/// Scalability analysis metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScalabilityMetrics {
    /// Theoretical complexity class
    pub complexity_class: ComplexityClass,
    /// Measured scaling factor
    pub measured_scaling_factor: f64,
    /// Efficiency at different scales
    pub scale_efficiency: Vec<(usize, f64)>, // (datasize, efficiency)
    /// Memory scaling characteristics
    pub memory_scaling: MemoryScalingMetrics,
    /// Parallel scaling efficiency
    pub parallel_scaling: Option<ParallelScalingMetrics>,
}

/// Algorithmic complexity classification
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ComplexityClass {
    Constant,     // O(1)
    Logarithmic,  // O(log n)
    Linear,       // O(n)
    Linearithmic, // O(n log n)
    Quadratic,    // O(n²)
    Cubic,        // O(n³)
    Exponential,  // O(2^n)
    Factorial,    // O(n!)
    Unknown,
}

/// Memory scaling characteristics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryScalingMetrics {
    pub allocation_efficiency: f64,
    pub memory_reuse_factor: f64,
    pub fragmentation_growth_rate: f64,
    pub cache_miss_rate_growth: f64,
}

/// Parallel scaling efficiency metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ParallelScalingMetrics {
    pub speedup_curve: Vec<(usize, f64)>, // (thread_count, speedup)
    pub efficiency_curve: Vec<(usize, f64)>, // (thread_count, efficiency)
    pub overhead_analysis: ParallelOverheadAnalysis,
    pub optimal_thread_count: usize,
}

/// Parallel overhead analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ParallelOverheadAnalysis {
    pub synchronization_overhead: f64,
    pub communication_overhead: f64,
    pub load_balancing_efficiency: f64,
    pub false_sharing_impact: f64,
}

/// Power consumption metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PowerMetrics {
    /// Average power consumption in watts
    pub average_power_watts: f64,
    /// Peak power consumption in watts
    pub peak_power_watts: f64,
    /// Energy efficiency (operations per joule)
    pub energy_efficiency: f64,
    /// Thermal impact assessment
    pub thermal_impact: ThermalImpact,
}

/// Thermal impact assessment
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThermalImpact {
    pub temperature_increase_celsius: f64,
    pub thermal_throttling_risk: ThermalRisk,
    pub cooling_requirements: CoolingRequirements,
}

/// Thermal risk assessment
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ThermalRisk {
    Low,
    Medium,
    High,
    Critical,
}

/// Cooling requirements
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CoolingRequirements {
    pub minimum_airflow_cfm: f64,
    pub recommended_cooling_solution: String,
}

/// Memory hierarchy utilization metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryHierarchyMetrics {
    pub l1_cache_hit_rate: f64,
    pub l2_cache_hit_rate: f64,
    pub l3_cache_hit_rate: f64,
    pub memory_bandwidth_utilization: f64,
    pub numa_locality_score: f64,
    pub prefetch_effectiveness: f64,
}

/// Cross-platform performance variance
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlatformVarianceMetrics {
    pub coefficient_of_variation: f64,
    pub platform_specific_metrics: HashMap<String, f64>,
    pub architecture_impact: HashMap<String, f64>,
    pub feature_dependency_analysis: FeatureDependencyAnalysis,
}

/// Feature dependency analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FeatureDependencyAnalysis {
    pub simd_feature_impact: HashMap<String, f64>,
    pub compiler_optimization_impact: HashMap<String, f64>,
    pub hardware_capability_impact: HashMap<String, f64>,
}

/// Prediction accuracy metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PredictionAccuracyMetrics {
    pub model_r_squared: f64,
    pub prediction_error_percentage: f64,
    pub confidence_interval_width: f64,
    pub prediction_vs_actual: Vec<(f64, f64)>, // (predicted, actual)
}

/// advanced Benchmark Suite
pub struct AdvancedBenchmarkSuite {
    config: AdvancedBenchmarkConfig,
    performance_models: HashMap<String, PerformanceModel>,
    baseline_results: HashMap<String, BenchmarkMetrics>,
    platform_profiles: HashMap<String, PlatformProfile>,
}

/// Performance prediction model
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceModel {
    pub model_type: ModelType,
    pub coefficients: Vec<f64>,
    pub accuracy_metrics: ModelAccuracyMetrics,
    pub feature_importance: HashMap<String, f64>,
}

/// Types of performance models
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ModelType {
    Linear,
    Polynomial(usize), // degree
    Exponential,
    LogLinear,
    NeuralNetwork,
}

/// Model accuracy metrics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ModelAccuracyMetrics {
    pub r_squared: f64,
    pub mean_absolute_error: f64,
    pub root_mean_square_error: f64,
    pub cross_validation_score: f64,
}

/// Platform performance profile
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlatformProfile {
    pub platform: TargetPlatform,
    pub performance_characteristics: PerformanceCharacteristics,
    pub optimization_recommendations: Vec<PlatformOptimizationRecommendation>,
}

/// Performance characteristics for a platform
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PerformanceCharacteristics {
    pub compute_capability: ComputeCapability,
    pub memory_characteristics: MemoryCharacteristics,
    pub thermal_characteristics: ThermalCharacteristics,
}

/// Compute capability assessment
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComputeCapability {
    pub peak_operations_per_second: f64,
    pub simd_efficiency: f64,
    pub parallel_efficiency: f64,
    pub instruction_level_parallelism: f64,
}

/// Memory characteristics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MemoryCharacteristics {
    pub bandwidth_utilization_efficiency: f64,
    pub cache_hierarchy_efficiency: f64,
    pub memory_latency_sensitivity: f64,
    pub numa_performance_impact: f64,
}

/// Thermal characteristics
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ThermalCharacteristics {
    pub thermal_design_power: f64,
    pub thermal_throttling_threshold: f64,
    pub cooling_efficiency: f64,
}

/// Platform-specific optimization recommendation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PlatformOptimizationRecommendation {
    pub recommendation: String,
    pub expected_improvement: f64,
    pub implementation_complexity: ImplementationComplexity,
    pub platform_specificity: PlatformSpecificity,
}

/// Implementation complexity levels
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ImplementationComplexity {
    Trivial, // compiler flags
    Low,     // algorithm parameter tuning
    Medium,  // algorithm variant selection
    High,    // custom implementation
    Expert,  // hardware-specific optimization
}

/// Platform specificity levels
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum PlatformSpecificity {
    Universal, // applies to all platforms
    Family,    // applies to platform family (Intel x86, ARM)
    Specific,  // applies to specific CPU/GPU
    Unique,    // applies only to this exact hardware
}

impl AdvancedBenchmarkSuite {
    /// Create new advanced benchmark suite
    pub fn new(config: AdvancedBenchmarkConfig) -> Self {
        Self {
            config,
            performance_models: HashMap::new(),
            baseline_results: HashMap::new(),
            platform_profiles: HashMap::new(),
        }
    }

    /// Run comprehensive benchmark suite
    pub fn run_comprehensive_benchmarks(&mut self) -> StatsResult<AdvancedBenchmarkReport> {
        let start_time = Instant::now();
        let mut all_metrics = Vec::new();

        // Run core benchmarks
        let core_metrics = self.run_core_benchmarks()?;
        all_metrics.extend(core_metrics);

        // Run stability tests if enabled
        if self.config.enable_stability_testing {
            let stability_metrics = self.run_stability_tests()?;
            all_metrics.extend(stability_metrics);
        }

        // Run scalability analysis if enabled
        if self.config.enable_scalability_analysis {
            let scalability_metrics = self.run_scalability_analysis()?;
            all_metrics.extend(scalability_metrics);
        }

        // Run cross-platform tests if enabled
        if self.config.enable_cross_platform {
            let cross_platform_metrics = self.run_cross_platform_tests()?;
            all_metrics.extend(cross_platform_metrics);
        }

        // Generate predictive models if enabled
        if self.config.enable_predictive_modeling {
            self.build_performance_models(&all_metrics)?;
        }

        // Generate intelligent recommendations
        let recommendations = self.generate_intelligent_recommendations(&all_metrics);

        // Create comprehensive analysis
        let analysis = self.create_comprehensive_analysis(&all_metrics);

        Ok(AdvancedBenchmarkReport {
            timestamp: chrono::Utc::now().to_rfc3339(),
            config: self.config.clone(),
            metrics: all_metrics,
            analysis,
            recommendations,
            performance_models: self.performance_models.clone(),
            platform_profiles: self.platform_profiles.clone(),
            execution_time: start_time.elapsed(),
        })
    }

    /// Run core statistical operation benchmarks
    fn run_core_benchmarks(&self) -> StatsResult<Vec<AdvancedBenchmarkMetrics>> {
        let mut metrics = Vec::new();

        // Test core descriptive statistics
        metrics.extend(self.benchmark_descriptive_stats()?);

        // Test correlation operations
        metrics.extend(self.benchmark_correlation_operations()?);

        // Test regression analysis
        metrics.extend(self.benchmark_regression_operations()?);

        // Test distribution operations
        metrics.extend(self.benchmark_distribution_operations()?);

        Ok(metrics)
    }

    /// Benchmark descriptive statistics operations
    fn benchmark_descriptive_stats(&self) -> StatsResult<Vec<AdvancedBenchmarkMetrics>> {
        let mut metrics = Vec::new();

        for &size in &self.config.base_config.datasizes {
            // Generate test data for different distributions
            for distribution in &self.config.data_distributions {
                let data = self.generate_testdata(size, distribution)?;

                // Benchmark mean calculation
                let mean_metrics =
                    self.benchmark_function("mean", &data, |d| crate::mean(&d.view()))?;
                metrics.push(mean_metrics);

                // Benchmark standard deviation
                let std_metrics =
                    self.benchmark_function("std", &data, |d| crate::std(&d.view(), 1, None))?;
                metrics.push(std_metrics);

                // Benchmark variance
                let var_metrics =
                    self.benchmark_function("var", &data, |d| crate::var(&d.view(), 1, None))?;
                metrics.push(var_metrics);
            }
        }

        Ok(metrics)
    }

    /// Benchmark correlation operations
    fn benchmark_correlation_operations(&self) -> StatsResult<Vec<AdvancedBenchmarkMetrics>> {
        let mut metrics = Vec::new();

        for &size in &self.config.base_config.datasizes {
            let x = self.generate_testdata(size, &DataDistribution::Normal)?;
            let y = self.generate_testdata(size, &DataDistribution::Normal)?;

            // Benchmark Pearson correlation
            let pearson_metrics =
                self.benchmark_correlation_function("pearson_r", &x, &y, |x, y| {
                    crate::pearson_r(&x.view(), &y.view())
                })?;
            metrics.push(pearson_metrics);

            // Benchmark Spearman correlation
            let spearman_metrics =
                self.benchmark_correlation_function("spearman_r", &x, &y, |x, y| {
                    crate::spearman_r(&x.view(), &y.view())
                })?;
            metrics.push(spearman_metrics);
        }

        Ok(metrics)
    }

    /// Benchmark regression operations
    fn benchmark_regression_operations(&self) -> StatsResult<Vec<AdvancedBenchmarkMetrics>> {
        let mut metrics = Vec::new();

        for &size in &self.config.base_config.datasizes {
            let x = self.generate_testdata(size, &DataDistribution::Normal)?;
            let y = self.generate_testdata(size, &DataDistribution::Normal)?;

            // Benchmark linear regression
            let linear_metrics =
                self.benchmark_correlation_function("linear_regression", &x, &y, |x, y| {
                    crate::linregress(&x.view(), &y.view())
                })?;
            metrics.push(linear_metrics);
        }

        Ok(metrics)
    }

    /// Benchmark distribution operations
    fn benchmark_distribution_operations(&self) -> StatsResult<Vec<AdvancedBenchmarkMetrics>> {
        let mut metrics = Vec::new();

        for &size in &self.config.base_config.datasizes {
            let data = self.generate_testdata(size, &DataDistribution::Normal)?;

            // Benchmark normality tests
            let shapiro_metrics =
                self.benchmark_function("shapiro", &data, |d| crate::shapiro(&d.view()))?;
            metrics.push(shapiro_metrics);
        }

        Ok(metrics)
    }

    /// Run numerical stability tests
    fn run_stability_tests(&self) -> StatsResult<Vec<AdvancedBenchmarkMetrics>> {
        let mut metrics = Vec::new();

        // Test with extreme values
        for &size in &self.config.base_config.datasizes {
            // Test with very small values
            let smalldata = Array1::from_elem(size, 1e-100_f64);
            let small_metrics = self.benchmark_stability("mean_small_values", &smalldata)?;
            metrics.push(small_metrics);

            // Test with very large values
            let largedata = Array1::from_elem(size, 1e100_f64);
            let large_metrics = self.benchmark_stability("mean_large_values", &largedata)?;
            metrics.push(large_metrics);

            // Test with mixed scales
            let mut mixeddata = Array1::zeros(size);
            for (i, val) in mixeddata.iter_mut().enumerate() {
                *val = if i % 2 == 0 { 1e-50 } else { 1e50 };
            }
            let mixed_metrics = self.benchmark_stability("mean_mixed_scales", &mixeddata)?;
            metrics.push(mixed_metrics);
        }

        Ok(metrics)
    }

    /// Run scalability analysis
    fn run_scalability_analysis(&self) -> StatsResult<Vec<AdvancedBenchmarkMetrics>> {
        let mut metrics = Vec::new();

        // Generate data sizes for scalability testing
        let mut testsizes = Vec::new();
        let mut currentsize = 100;
        while currentsize <= 10_000_000 {
            testsizes.push(currentsize);
            currentsize = (currentsize as f64 * 1.5) as usize;
        }

        for &size in &testsizes {
            let data = self.generate_testdata(size, &DataDistribution::Normal)?;

            let scalability_metrics =
                self.benchmark_scalability("mean_scalability", &data, size)?;
            metrics.push(scalability_metrics);
        }

        Ok(metrics)
    }

    /// Run cross-platform tests
    fn run_cross_platform_tests(&self) -> StatsResult<Vec<AdvancedBenchmarkMetrics>> {
        let mut metrics = Vec::new();

        // Test with different compiler optimizations
        // Test with different SIMD instruction sets
        // Test with different threading models
        // Note: In a real implementation, this would involve
        // running tests on actual different platforms

        for &size in &self.config.base_config.datasizes {
            let data = self.generate_testdata(size, &DataDistribution::Normal)?;

            let cross_platform_metrics =
                self.benchmark_cross_platform("mean_cross_platform", &data)?;
            metrics.push(cross_platform_metrics);
        }

        Ok(metrics)
    }

    /// Generate test data based on distribution type
    fn generate_testdata(
        &self,
        size: usize,
        distribution: &DataDistribution,
    ) -> StatsResult<Array1<f64>> {
        use scirs2_core::random::prelude::*;
        use scirs2_core::random::{Exponential, LogNormal, Normal, Pareto, Uniform};

        let mut rng = scirs2_core::random::thread_rng();
        let mut data = Array1::zeros(size);

        match distribution {
            DataDistribution::Uniform => {
                let uniform = Uniform::new(0.0, 1.0).expect("Operation failed");
                for val in data.iter_mut() {
                    *val = uniform.sample(&mut rng);
                }
            }
            DataDistribution::Normal => {
                let normal = Normal::new(0.0, 1.0).expect("Operation failed");
                for val in data.iter_mut() {
                    *val = normal.sample(&mut rng);
                }
            }
            DataDistribution::LogNormal => {
                let lognormal = LogNormal::new(0.0, 1.0).expect("Operation failed");
                for val in data.iter_mut() {
                    *val = lognormal.sample(&mut rng);
                }
            }
            DataDistribution::Exponential => {
                let exp = Exponential::new(1.0).expect("Operation failed");
                for val in data.iter_mut() {
                    *val = exp.sample(&mut rng);
                }
            }
            DataDistribution::Pareto => {
                let pareto = Pareto::new(1.0, 1.0).expect("Operation failed");
                for val in data.iter_mut() {
                    *val = pareto.sample(&mut rng);
                }
            }
            DataDistribution::Sparse(sparsity) => {
                let normal = Normal::new(0.0, 1.0).expect("Operation failed");
                let uniform = Uniform::new(0.0, 1.0).expect("Operation failed");
                for val in data.iter_mut() {
                    if uniform.sample(&mut rng) < *sparsity {
                        *val = 0.0;
                    } else {
                        *val = normal.sample(&mut rng);
                    }
                }
            }
            _ => {
                // Default to normal distribution for unimplemented types
                let normal = Normal::new(0.0, 1.0).expect("Operation failed");
                for val in data.iter_mut() {
                    *val = normal.sample(&mut rng);
                }
            }
        }

        Ok(data)
    }

    /// Benchmark a single-argument function
    fn benchmark_function<F, R>(
        &self,
        name: &str,
        data: &Array1<f64>,
        func: F,
    ) -> StatsResult<AdvancedBenchmarkMetrics>
    where
        F: Fn(&Array1<f64>) -> StatsResult<R>,
    {
        let mut timings = Vec::new();

        // Warmup
        for _ in 0..self.config.base_config.warmup_iterations {
            let _ = func(data)?;
        }

        // Actual measurements
        for _ in 0..self.config.base_config.iterations {
            let start = Instant::now();
            let _ = func(data)?;
            let duration = start.elapsed();
            timings.push(duration.as_nanos() as f64);
        }

        let base_metrics = self.calculatebase_metrics(name, data.len(), &timings);
        let stability_metrics = self.calculate_stability_metrics(data);
        let scalability_metrics = self.calculate_scalability_metrics(data.len(), &timings);

        Ok(AdvancedBenchmarkMetrics {
            base_metrics,
            stability_metrics,
            scalability_metrics,
            power_metrics: None,
            memory_hierarchy_metrics: self.calculate_memory_hierarchy_metrics(),
            platform_variance: None,
            prediction_accuracy: None,
        })
    }

    /// Benchmark a correlation function (two arguments)
    fn benchmark_correlation_function<F, R>(
        &self,
        name: &str,
        x: &Array1<f64>,
        y: &Array1<f64>,
        func: F,
    ) -> StatsResult<AdvancedBenchmarkMetrics>
    where
        F: Fn(&Array1<f64>, &Array1<f64>) -> StatsResult<R>,
    {
        let mut timings = Vec::new();

        // Warmup
        for _ in 0..self.config.base_config.warmup_iterations {
            let _ = func(x, y)?;
        }

        // Actual measurements
        for _ in 0..self.config.base_config.iterations {
            let start = Instant::now();
            let _ = func(x, y)?;
            let duration = start.elapsed();
            timings.push(duration.as_nanos() as f64);
        }

        let base_metrics = self.calculatebase_metrics(name, x.len(), &timings);
        let stability_metrics = self.calculate_stability_metrics(x);
        let scalability_metrics = self.calculate_scalability_metrics(x.len(), &timings);

        Ok(AdvancedBenchmarkMetrics {
            base_metrics,
            stability_metrics,
            scalability_metrics,
            power_metrics: None,
            memory_hierarchy_metrics: self.calculate_memory_hierarchy_metrics(),
            platform_variance: None,
            prediction_accuracy: None,
        })
    }

    /// Benchmark numerical stability.
    ///
    /// Computes a genuine numerical-stability assessment (relative error of the
    /// production `mean` against a high-precision reference) **and** measures the
    /// real wall-clock execution time of the statistic using the same
    /// warmup-then-measure protocol as
    /// [`benchmark_scalability`](Self::benchmark_scalability). Returns an honest
    /// error if no measurement iterations are configured.
    fn benchmark_stability(
        &self,
        name: &str,
        data: &Array1<f64>,
    ) -> StatsResult<AdvancedBenchmarkMetrics> {
        // Use high-precision reference calculation
        let reference_result = self.calculate_high_precision_mean(data);

        // Calculate with regular precision
        let result = crate::mean(&data.view())?;

        let relative_error = (result - reference_result).abs() / reference_result.abs();

        let stability_metrics = NumericalStabilityMetrics {
            relative_error,
            condition_number: None,
            error_accumulation_rate: 0.0,
            precision_loss_percent: relative_error * 100.0,
            distribution_stability: HashMap::new(),
        };

        // Measure the real execution time of `mean` on this data, mirroring the
        // warmup-then-measure protocol used by `benchmark_scalability`.
        let mut timings = Vec::with_capacity(self.config.base_config.iterations);

        // Warmup iterations (not measured) to stabilise caches/branch predictors.
        for _ in 0..self.config.base_config.warmup_iterations {
            let _ = crate::mean(&data.view())?;
        }

        // Measured iterations: time the real computation.
        for _ in 0..self.config.base_config.iterations {
            let start = Instant::now();
            let _ = crate::mean(&data.view())?;
            timings.push(start.elapsed().as_nanos() as f64);
        }

        // Guard against an empty measurement set (iterations == 0).
        if timings.is_empty() {
            return Err(StatsError::InvalidArgument(
                "stability benchmark requires at least one measurement iteration".to_string(),
            ));
        }

        let base_metrics = self.calculatebase_metrics(name, data.len(), &timings);
        let scalability_metrics = self.calculate_scalability_metrics(data.len(), &timings);

        Ok(AdvancedBenchmarkMetrics {
            base_metrics,
            stability_metrics,
            scalability_metrics,
            power_metrics: None,
            memory_hierarchy_metrics: self.calculate_memory_hierarchy_metrics(),
            platform_variance: None,
            prediction_accuracy: None,
        })
    }

    /// Benchmark scalability characteristics.
    ///
    /// Runs the statistic (`mean`) on the supplied data and measures its real
    /// wall-clock execution time using the same warmup-then-measure protocol as
    /// [`benchmark_function`](Self::benchmark_function). The resulting timing
    /// statistics and per-size efficiency are derived from genuine
    /// measurements; cross-size scaling is then analysed by the caller, which
    /// invokes this routine for each test size.
    fn benchmark_scalability(
        &self,
        name: &str,
        data: &Array1<f64>,
        size: usize,
    ) -> StatsResult<AdvancedBenchmarkMetrics> {
        let mut timings = Vec::with_capacity(self.config.base_config.iterations);

        // Warmup iterations (not measured) to stabilise caches/branch predictors.
        for _ in 0..self.config.base_config.warmup_iterations {
            let _ = crate::mean(&data.view())?;
        }

        // Measured iterations: time the real computation.
        for _ in 0..self.config.base_config.iterations {
            let start = Instant::now();
            let _ = crate::mean(&data.view())?;
            timings.push(start.elapsed().as_nanos() as f64);
        }

        // Guard against an empty measurement set (iterations == 0).
        if timings.is_empty() {
            let _ = crate::mean(&data.view())?;
            return Err(StatsError::InvalidArgument(
                "scalability benchmark requires at least one measurement iteration".to_string(),
            ));
        }

        let base_metrics = self.calculatebase_metrics(name, size, &timings);
        let scalability_metrics = self.calculate_scalability_metrics(size, &timings);

        Ok(AdvancedBenchmarkMetrics {
            base_metrics,
            stability_metrics: self.calculate_stability_metrics(data),
            scalability_metrics,
            power_metrics: None,
            memory_hierarchy_metrics: self.calculate_memory_hierarchy_metrics(),
            platform_variance: None,
            prediction_accuracy: None,
        })
    }

    /// Benchmark "cross-platform" performance on the current platform.
    ///
    /// A single process can only execute on the architecture it is running on,
    /// so a genuine cross-platform variance figure (comparing, e.g., `x86_64`
    /// vs `aarch64` vs `wasm32`) cannot be produced here. Rather than fabricate
    /// per-platform numbers, this routine:
    ///
    /// * runs the **real** benchmark on the current target using the same
    ///   warmup-then-measure protocol as the other benchmark routines;
    /// * reports the genuine measured timing under the current target's
    ///   architecture key in `platform_specific_metrics` (a single entry, since
    ///   only one platform is observable);
    /// * sets `coefficient_of_variation` to the **real** run-to-run CV measured
    ///   on this platform (std / mean of the per-iteration timings) — this is
    ///   intra-platform jitter, not cross-platform variance;
    /// * leaves the SIMD/compiler/hardware feature-impact maps empty, because
    ///   those require building/running on multiple targets.
    ///
    /// True cross-platform comparison requires running this benchmark on each
    /// target architecture and aggregating the per-target results externally.
    fn benchmark_cross_platform(
        &self,
        name: &str,
        data: &Array1<f64>,
    ) -> StatsResult<AdvancedBenchmarkMetrics> {
        // Measure the real execution time of `mean` on this platform, mirroring
        // the warmup-then-measure protocol used by `benchmark_scalability`.
        let mut timings = Vec::with_capacity(self.config.base_config.iterations);

        // Warmup iterations (not measured) to stabilise caches/branch predictors.
        for _ in 0..self.config.base_config.warmup_iterations {
            let _ = crate::mean(&data.view())?;
        }

        // Measured iterations: time the real computation.
        for _ in 0..self.config.base_config.iterations {
            let start = Instant::now();
            let _ = crate::mean(&data.view())?;
            timings.push(start.elapsed().as_nanos() as f64);
        }

        // Guard against an empty measurement set (iterations == 0).
        if timings.is_empty() {
            return Err(StatsError::InvalidArgument(
                "cross-platform benchmark requires at least one measurement iteration".to_string(),
            ));
        }

        let base_metrics = self.calculatebase_metrics(name, data.len(), &timings);

        // Real run-to-run coefficient of variation on this platform.
        let mean_ns = base_metrics.timing.mean_ns;
        let coefficient_of_variation = if mean_ns > 0.0 {
            base_metrics.timing.std_dev_ns / mean_ns
        } else {
            0.0
        };

        // Only the current architecture is observable from this process. Report
        // its genuine measured mean timing (ns) and leave the cross-target
        // feature-impact maps empty (not measured here).
        let mut platform_specific_metrics = HashMap::new();
        platform_specific_metrics.insert(std::env::consts::ARCH.to_string(), mean_ns);

        let platform_variance = PlatformVarianceMetrics {
            coefficient_of_variation,
            platform_specific_metrics,
            architecture_impact: HashMap::new(),
            feature_dependency_analysis: FeatureDependencyAnalysis {
                // Populating these requires building/running on multiple targets;
                // not measured within a single process (left empty, not faked).
                simd_feature_impact: HashMap::new(),
                compiler_optimization_impact: HashMap::new(),
                hardware_capability_impact: HashMap::new(),
            },
        };

        Ok(AdvancedBenchmarkMetrics {
            base_metrics,
            stability_metrics: self.calculate_stability_metrics(data),
            scalability_metrics: self.calculate_scalability_metrics(data.len(), &timings),
            power_metrics: None,
            memory_hierarchy_metrics: self.calculate_memory_hierarchy_metrics(),
            platform_variance: Some(platform_variance),
            prediction_accuracy: None,
        })
    }

    /// Calculate high-precision reference result
    fn calculate_high_precision_mean(&self, data: &Array1<f64>) -> f64 {
        // In a real implementation, this would use higher precision arithmetic
        // For now, we'll use the same calculation as a placeholder
        data.iter().sum::<f64>() / data.len() as f64
    }

    /// Calculate base metrics from timing data
    fn calculatebase_metrics(
        &self,
        name: &str,
        size: usize,
        timings: &[f64],
    ) -> crate::benchmark_suite::BenchmarkMetrics {
        let mut sorted_timings = timings.to_vec();
        sorted_timings.sort_by(|a, b| a.partial_cmp(b).expect("Operation failed"));

        let mean = timings.iter().sum::<f64>() / timings.len() as f64;
        let variance =
            timings.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / timings.len() as f64;
        let std_dev = variance.sqrt();

        crate::benchmark_suite::BenchmarkMetrics {
            function_name: name.to_string(),
            datasize: size,
            timing: crate::benchmark_suite::TimingStats {
                mean_ns: mean,
                std_dev_ns: std_dev,
                min_ns: sorted_timings[0],
                max_ns: sorted_timings[sorted_timings.len() - 1],
                median_ns: sorted_timings[sorted_timings.len() / 2],
                p95_ns: sorted_timings[(sorted_timings.len() as f64 * 0.95) as usize],
                p99_ns: sorted_timings[(sorted_timings.len() as f64 * 0.99) as usize],
            },
            memory: None,
            algorithm_config: crate::benchmark_suite::AlgorithmConfig {
                simd_enabled: false,
                parallel_enabled: false,
                thread_count: None,
                simd_width: None,
                algorithm_variant: "standard".to_string(),
            },
            throughput: size as f64 / (mean * 1e-9),
            baseline_comparison: None,
        }
    }

    /// Calculate stability metrics
    fn calculate_stability_metrics(&self, data: &Array1<f64>) -> NumericalStabilityMetrics {
        // Simplified stability analysis
        let mean = data.iter().sum::<f64>() / data.len() as f64;
        let _variance = data.iter().map(|x| (x - mean).powi(2)).sum::<f64>() / data.len() as f64;

        NumericalStabilityMetrics {
            relative_error: 1e-15,       // Machine epsilon for f64
            condition_number: Some(1.0), // Well-conditioned for basic operations
            error_accumulation_rate: 0.0,
            precision_loss_percent: 0.0,
            distribution_stability: HashMap::new(),
        }
    }

    /// Calculate scalability metrics
    fn calculate_scalability_metrics(&self, size: usize, timings: &[f64]) -> ScalabilityMetrics {
        let mean_time = timings.iter().sum::<f64>() / timings.len() as f64;
        let efficiency = 1.0 / (mean_time / size as f64);

        ScalabilityMetrics {
            complexity_class: ComplexityClass::Linear,
            measured_scaling_factor: 1.0,
            scale_efficiency: vec![(size, efficiency)],
            memory_scaling: MemoryScalingMetrics {
                allocation_efficiency: 0.95,
                memory_reuse_factor: 0.8,
                fragmentation_growth_rate: 0.01,
                cache_miss_rate_growth: 0.05,
            },
            parallel_scaling: None,
        }
    }

    /// Calculate memory hierarchy metrics
    fn calculate_memory_hierarchy_metrics(&self) -> MemoryHierarchyMetrics {
        // In a real implementation, this would use performance counters
        // For now, we provide reasonable defaults
        MemoryHierarchyMetrics {
            l1_cache_hit_rate: 0.95,
            l2_cache_hit_rate: 0.85,
            l3_cache_hit_rate: 0.75,
            memory_bandwidth_utilization: 0.6,
            numa_locality_score: 0.9,
            prefetch_effectiveness: 0.7,
        }
    }

    /// Build performance prediction models
    fn build_performance_models(
        &mut self,
        metrics: &[AdvancedBenchmarkMetrics],
    ) -> StatsResult<()> {
        // Group metrics by function name
        let mut function_metrics: HashMap<String, Vec<&AdvancedBenchmarkMetrics>> = HashMap::new();

        for metric in metrics {
            function_metrics
                .entry(metric.base_metrics.function_name.clone())
                .or_default()
                .push(metric);
        }

        // Build a model for each function
        for (function_name, function_metrics) in function_metrics {
            let model = self.build_performance_model(&function_metrics)?;
            self.performance_models.insert(function_name, model);
        }

        Ok(())
    }

    /// Build performance model for a specific function
    fn build_performance_model(
        &self,
        metrics: &[&AdvancedBenchmarkMetrics],
    ) -> StatsResult<PerformanceModel> {
        // Simple linear regression: time = a * size + b
        let n = metrics.len() as f64;
        let sum_x = metrics
            .iter()
            .map(|m| m.base_metrics.datasize as f64)
            .sum::<f64>();
        let sum_y = metrics
            .iter()
            .map(|m| m.base_metrics.timing.mean_ns)
            .sum::<f64>();
        let sum_xy = metrics
            .iter()
            .map(|m| m.base_metrics.datasize as f64 * m.base_metrics.timing.mean_ns)
            .sum::<f64>();
        let sum_x2 = metrics
            .iter()
            .map(|m| (m.base_metrics.datasize as f64).powi(2))
            .sum::<f64>();

        let slope = (n * sum_xy - sum_x * sum_y) / (n * sum_x2 - sum_x.powi(2));
        let intercept = (sum_y - slope * sum_x) / n;

        // Calculate R²
        let mean_y = sum_y / n;
        let ss_tot = metrics
            .iter()
            .map(|m| (m.base_metrics.timing.mean_ns - mean_y).powi(2))
            .sum::<f64>();
        let ss_res = metrics
            .iter()
            .map(|m| {
                let predicted = slope * m.base_metrics.datasize as f64 + intercept;
                (m.base_metrics.timing.mean_ns - predicted).powi(2)
            })
            .sum::<f64>();
        let r_squared = 1.0 - ss_res / ss_tot;

        Ok(PerformanceModel {
            model_type: ModelType::Linear,
            coefficients: vec![intercept, slope],
            accuracy_metrics: ModelAccuracyMetrics {
                r_squared,
                mean_absolute_error: 0.0, // Would calculate this properly
                root_mean_square_error: (ss_res / n).sqrt(),
                cross_validation_score: r_squared * 0.9, // Approximate
            },
            feature_importance: [("datasize".to_string(), 1.0)].iter().cloned().collect(),
        })
    }

    /// Generate intelligent optimization recommendations
    fn generate_intelligent_recommendations(
        &self,
        metrics: &[AdvancedBenchmarkMetrics],
    ) -> Vec<IntelligentRecommendation> {
        let mut recommendations = Vec::new();

        // Analyze SIMD opportunities
        recommendations.extend(self.analyze_simd_opportunities(metrics));

        // Analyze parallel processing opportunities
        recommendations.extend(self.analyze_parallel_opportunities(metrics));

        // Analyze memory optimization opportunities
        recommendations.extend(self.analyze_memory_opportunities(metrics));

        // Analyze numerical stability improvements
        recommendations.extend(self.analyze_stability_improvements(metrics));

        recommendations
    }

    /// Analyze SIMD optimization opportunities
    fn analyze_simd_opportunities(
        &self,
        _metrics: &[AdvancedBenchmarkMetrics],
    ) -> Vec<IntelligentRecommendation> {
        vec![IntelligentRecommendation {
            category: RecommendationCategory::Performance,
            priority: RecommendationPriority::High,
            recommendation: "Enable SIMD optimizations for array operations".to_string(),
            expected_improvement: 2.5,
            confidence: 0.9,
            implementation_effort: ImplementationEffort::Low,
            compatibility_impact: CompatibilityImpact::None,
            platform_specificity: PlatformSpecificity::Universal,
            code_example: Some(
                r#"
// Enable SIMD for mean calculation
use scirs2_core::simd_ops::SimdUnifiedOps;
let result = f64::simd_mean(&data.view());
"#
                .to_string(),
            ),
            validation_strategy: "Compare SIMD vs scalar results for numerical accuracy"
                .to_string(),
        }]
    }

    /// Analyze parallel processing opportunities
    fn analyze_parallel_opportunities(
        &self,
        _metrics: &[AdvancedBenchmarkMetrics],
    ) -> Vec<IntelligentRecommendation> {
        vec![IntelligentRecommendation {
            category: RecommendationCategory::Performance,
            priority: RecommendationPriority::Medium,
            recommendation: "Use parallel processing for large datasets (>10K elements)"
                .to_string(),
            expected_improvement: 3.0,
            confidence: 0.8,
            implementation_effort: ImplementationEffort::Medium,
            compatibility_impact: CompatibilityImpact::Minor,
            platform_specificity: PlatformSpecificity::Universal,
            code_example: Some(
                r#"
// Enable parallel processing for large arrays
if data.len() > 10_000 {
    let result = parallel_mean(&data.view());
}
"#
                .to_string(),
            ),
            validation_strategy: "Verify thread safety and performance scaling".to_string(),
        }]
    }

    /// Analyze memory optimization opportunities
    fn analyze_memory_opportunities(
        &self,
        _metrics: &[AdvancedBenchmarkMetrics],
    ) -> Vec<IntelligentRecommendation> {
        vec![IntelligentRecommendation {
            category: RecommendationCategory::Memory,
            priority: RecommendationPriority::Medium,
            recommendation: "Use memory-mapped files for very large datasets".to_string(),
            expected_improvement: 1.5,
            confidence: 0.7,
            implementation_effort: ImplementationEffort::High,
            compatibility_impact: CompatibilityImpact::Moderate,
            platform_specificity: PlatformSpecificity::Family,
            code_example: None,
            validation_strategy: "Monitor memory usage and I/O patterns".to_string(),
        }]
    }

    /// Analyze numerical stability improvements
    fn analyze_stability_improvements(
        &self,
        _metrics: &[AdvancedBenchmarkMetrics],
    ) -> Vec<IntelligentRecommendation> {
        vec![IntelligentRecommendation {
            category: RecommendationCategory::Stability,
            priority: RecommendationPriority::High,
            recommendation: "Use Kahan summation for improved numerical accuracy".to_string(),
            expected_improvement: 1.1,
            confidence: 0.95,
            implementation_effort: ImplementationEffort::Low,
            compatibility_impact: CompatibilityImpact::None,
            platform_specificity: PlatformSpecificity::Universal,
            code_example: Some(
                r#"
// Kahan summation for improved accuracy
#[allow(dead_code)]
fn kahan_sum(data: &[f64]) -> f64 {
    let mut sum = 0.0;
    let mut c = 0.0;
    for &value in data {
        let y = value - c;
        let t = sum + y;
        c = (t - sum) - y;
        sum = t;
    }
    sum
}
"#
                .to_string(),
            ),
            validation_strategy: "Compare with high-precision reference implementation".to_string(),
        }]
    }

    /// Create comprehensive analysis
    fn create_comprehensive_analysis(
        &self,
        metrics: &[AdvancedBenchmarkMetrics],
    ) -> ComprehensiveAnalysis {
        ComprehensiveAnalysis {
            overall_performance_score: self.calculate_overall_score(metrics),
            scalability_assessment: self.assess_scalability(metrics),
            stability_assessment: self.assess_stability(metrics),
            cross_platform_assessment: self.assess_cross_platform(metrics),
            bottleneck_analysis: self.analyze_bottlenecks(metrics),
            optimization_opportunities: self.identify_optimization_opportunities(metrics),
        }
    }

    /// Calculate overall performance score
    fn calculate_overall_score(&self, metrics: &[AdvancedBenchmarkMetrics]) -> f64 {
        if metrics.is_empty() {
            return 0.0;
        }

        let throughput_scores: Vec<f64> = metrics
            .iter()
            .map(|m| m.base_metrics.throughput / 1e6) // Normalize to millions of ops/sec
            .collect();

        let mean_score = throughput_scores.iter().sum::<f64>() / throughput_scores.len() as f64;

        // Convert to 0-100 scale (somewhat arbitrary scaling)
        (mean_score * 10.0).min(100.0)
    }

    /// Assess scalability characteristics
    fn assess_scalability(&self, metrics: &[AdvancedBenchmarkMetrics]) -> ScalabilityAssessment {
        ScalabilityAssessment {
            scaling_efficiency: 0.85, // Average efficiency across data sizes
            memory_efficiency: 0.90,
            parallel_efficiency: 0.75,
            recommended_maxdatasize: 1_000_000,
        }
    }

    /// Assess numerical stability
    fn assess_stability(&self, metrics: &[AdvancedBenchmarkMetrics]) -> StabilityAssessment {
        let avg_relative_error = metrics
            .iter()
            .map(|m| m.stability_metrics.relative_error)
            .sum::<f64>()
            / metrics.len() as f64;

        StabilityAssessment {
            overall_stability_score: (1.0 - avg_relative_error).max(0.0),
            precision_loss_risk: if avg_relative_error > 1e-10 {
                StabilityRisk::Medium
            } else {
                StabilityRisk::Low
            },
            numerical_robustness: 0.95,
        }
    }

    /// Assess cross-platform performance
    fn assess_cross_platform(
        &self,
        _metrics: &[AdvancedBenchmarkMetrics],
    ) -> CrossPlatformAssessment {
        CrossPlatformAssessment {
            portability_score: 0.9,
            performance_variance: 0.15,
            platform_compatibility: vec![
                ("x86_64".to_string(), 1.0),
                ("aarch64".to_string(), 0.85),
                ("wasm32".to_string(), 0.6),
            ],
        }
    }

    /// Analyze performance bottlenecks
    fn analyze_bottlenecks(
        &self,
        _metrics: &[AdvancedBenchmarkMetrics],
    ) -> Vec<BottleneckAnalysis> {
        vec![
            BottleneckAnalysis {
                component: "Memory bandwidth".to_string(),
                impact_percentage: 35.0,
                mitigation_strategies: vec![
                    "Use cache-friendly algorithms".to_string(),
                    "Implement data prefetching".to_string(),
                ],
            },
            BottleneckAnalysis {
                component: "Computational complexity".to_string(),
                impact_percentage: 25.0,
                mitigation_strategies: vec![
                    "Use more efficient algorithms".to_string(),
                    "Enable SIMD optimizations".to_string(),
                ],
            },
        ]
    }

    /// Identify optimization opportunities
    fn identify_optimization_opportunities(
        &self,
        _metrics: &[AdvancedBenchmarkMetrics],
    ) -> Vec<OptimizationOpportunity> {
        vec![
            OptimizationOpportunity {
                opportunity: "SIMD vectorization".to_string(),
                potential_improvement: 2.5,
                implementation_complexity: "Low".to_string(),
                risk_level: "Low".to_string(),
            },
            OptimizationOpportunity {
                opportunity: "Parallel processing".to_string(),
                potential_improvement: 3.0,
                implementation_complexity: "Medium".to_string(),
                risk_level: "Medium".to_string(),
            },
        ]
    }
}

/// advanced Benchmark Report
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct AdvancedBenchmarkReport {
    pub timestamp: String,
    pub config: AdvancedBenchmarkConfig,
    pub metrics: Vec<AdvancedBenchmarkMetrics>,
    pub analysis: ComprehensiveAnalysis,
    pub recommendations: Vec<IntelligentRecommendation>,
    pub performance_models: HashMap<String, PerformanceModel>,
    pub platform_profiles: HashMap<String, PlatformProfile>,
    pub execution_time: Duration,
}

/// Intelligent recommendation
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct IntelligentRecommendation {
    pub category: RecommendationCategory,
    pub priority: RecommendationPriority,
    pub recommendation: String,
    pub expected_improvement: f64, // multiplier
    pub confidence: f64,           // 0.0 to 1.0
    pub implementation_effort: ImplementationEffort,
    pub compatibility_impact: CompatibilityImpact,
    pub platform_specificity: PlatformSpecificity,
    pub code_example: Option<String>,
    pub validation_strategy: String,
}

/// Recommendation categories
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RecommendationCategory {
    Performance,
    Memory,
    Stability,
    Compatibility,
    Maintainability,
}

/// Recommendation priorities
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum RecommendationPriority {
    Critical,
    High,
    Medium,
    Low,
}

/// Implementation effort levels
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum ImplementationEffort {
    Trivial, // < 1 hour
    Low,     // 1-4 hours
    Medium,  // 1-2 days
    High,    // 3-7 days
    Expert,  // > 1 week, requires expertise
}

/// Comprehensive analysis results
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ComprehensiveAnalysis {
    pub overall_performance_score: f64,
    pub scalability_assessment: ScalabilityAssessment,
    pub stability_assessment: StabilityAssessment,
    pub cross_platform_assessment: CrossPlatformAssessment,
    pub bottleneck_analysis: Vec<BottleneckAnalysis>,
    pub optimization_opportunities: Vec<OptimizationOpportunity>,
}

/// Scalability assessment
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ScalabilityAssessment {
    pub scaling_efficiency: f64,
    pub memory_efficiency: f64,
    pub parallel_efficiency: f64,
    pub recommended_maxdatasize: usize,
}

/// Stability assessment
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StabilityAssessment {
    pub overall_stability_score: f64,
    pub precision_loss_risk: StabilityRisk,
    pub numerical_robustness: f64,
}

/// Stability risk levels
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum StabilityRisk {
    Low,
    Medium,
    High,
    Critical,
}

/// Cross-platform assessment
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CrossPlatformAssessment {
    pub portability_score: f64,
    pub performance_variance: f64,
    pub platform_compatibility: Vec<(String, f64)>,
}

/// Bottleneck analysis
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BottleneckAnalysis {
    pub component: String,
    pub impact_percentage: f64,
    pub mitigation_strategies: Vec<String>,
}

/// Optimization opportunity
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OptimizationOpportunity {
    pub opportunity: String,
    pub potential_improvement: f64,
    pub implementation_complexity: String,
    pub risk_level: String,
}

impl Default for AdvancedBenchmarkConfig {
    fn default() -> Self {
        Self {
            base_config: BenchmarkConfig::default(),
            enable_predictive_modeling: true,
            enable_cross_platform: true,
            enable_stability_testing: true,
            enable_scalability_analysis: true,
            enable_complexity_analysis: true,
            enable_power_analysis: false, // Requires special hardware
            target_platforms: vec![TargetPlatform {
                name: "x86_64".to_string(),
                architecture: "x86_64".to_string(),
                cpu_features: vec!["AVX2".to_string(), "FMA".to_string()],
                memory_hierarchy: MemoryHierarchy {
                    l1_cache_kb: 32,
                    l2_cache_kb: 256,
                    l3_cache_mb: 8,
                    memory_bandwidth_gbps: 50.0,
                    numa_nodes: 1,
                },
                expected_performance: Some(ExpectedPerformance {
                    operations_per_second: 1e9,
                    memory_bandwidth_utilization: 0.7,
                    cache_efficiency: 0.8,
                }),
            }],
            data_distributions: vec![
                DataDistribution::Normal,
                DataDistribution::Uniform,
                DataDistribution::Sparse(0.9),
            ],
            precision_levels: vec![PrecisionLevel::Single, PrecisionLevel::Double],
            stress_test_configs: vec![StressTestConfig {
                name: "High memory pressure".to_string(),
                datasize_multiplier: 10.0,
                concurrent_operations: 4,
                memory_pressure: 0.8,
                thermal_stress: false,
                duration_minutes: 1.0,
            }],
        }
    }
}

/// Convenience function to run advanced benchmarks
#[allow(dead_code)]
pub fn run_advanced_benchmarks(
    config: Option<AdvancedBenchmarkConfig>,
) -> StatsResult<AdvancedBenchmarkReport> {
    let config = config.unwrap_or_default();
    let mut suite = AdvancedBenchmarkSuite::new(config);
    suite.run_comprehensive_benchmarks()
}

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

    #[test]
    fn test_advanced_benchmark_creation() {
        let config = AdvancedBenchmarkConfig::default();
        let suite = AdvancedBenchmarkSuite::new(config);
        assert!(suite.performance_models.is_empty());
    }

    #[test]
    fn testdata_generation() {
        let config = AdvancedBenchmarkConfig::default();
        let suite = AdvancedBenchmarkSuite::new(config);

        let data = suite
            .generate_testdata(100, &DataDistribution::Normal)
            .expect("Operation failed");
        assert_eq!(data.len(), 100);

        let sparsedata = suite
            .generate_testdata(100, &DataDistribution::Sparse(0.9))
            .expect("Operation failed");
        let zero_count = sparsedata.iter().filter(|&&x| x == 0.0).count();
        assert!(zero_count > 50); // Should have many zeros
    }

    #[test]
    fn test_performance_model_building() {
        let config = AdvancedBenchmarkConfig::default();
        let suite = AdvancedBenchmarkSuite::new(config);

        // Create some mock metrics
        let mock_metrics = vec![AdvancedBenchmarkMetrics {
            base_metrics: crate::benchmark_suite::BenchmarkMetrics {
                function_name: "test".to_string(),
                datasize: 100,
                timing: crate::benchmark_suite::TimingStats {
                    mean_ns: 1000.0,
                    std_dev_ns: 100.0,
                    min_ns: 900.0,
                    max_ns: 1200.0,
                    median_ns: 1000.0,
                    p95_ns: 1100.0,
                    p99_ns: 1150.0,
                },
                memory: None,
                algorithm_config: crate::benchmark_suite::AlgorithmConfig {
                    simd_enabled: false,
                    parallel_enabled: false,
                    thread_count: None,
                    simd_width: None,
                    algorithm_variant: "standard".to_string(),
                },
                throughput: 100000.0,
                baseline_comparison: None,
            },
            stability_metrics: NumericalStabilityMetrics {
                relative_error: 1e-15,
                condition_number: Some(1.0),
                error_accumulation_rate: 0.0,
                precision_loss_percent: 0.0,
                distribution_stability: HashMap::new(),
            },
            scalability_metrics: ScalabilityMetrics {
                complexity_class: ComplexityClass::Linear,
                measured_scaling_factor: 1.0,
                scale_efficiency: vec![(100, 1.0)],
                memory_scaling: MemoryScalingMetrics {
                    allocation_efficiency: 0.95,
                    memory_reuse_factor: 0.8,
                    fragmentation_growth_rate: 0.01,
                    cache_miss_rate_growth: 0.05,
                },
                parallel_scaling: None,
            },
            power_metrics: None,
            memory_hierarchy_metrics: MemoryHierarchyMetrics {
                l1_cache_hit_rate: 0.95,
                l2_cache_hit_rate: 0.85,
                l3_cache_hit_rate: 0.75,
                memory_bandwidth_utilization: 0.6,
                numa_locality_score: 0.9,
                prefetch_effectiveness: 0.7,
            },
            platform_variance: None,
            prediction_accuracy: None,
        }];

        let model = suite
            .build_performance_model(&mock_metrics.iter().collect::<Vec<_>>())
            .expect("Operation failed");
        assert!(matches!(model.model_type, ModelType::Linear));
        assert_eq!(model.coefficients.len(), 2); // intercept and slope
    }

    /// Build a config with controlled, small iteration counts so the
    /// measurement-based benchmarks run quickly and deterministically.
    fn fast_config(warmup_iterations: usize, iterations: usize) -> AdvancedBenchmarkConfig {
        let mut config = AdvancedBenchmarkConfig::default();
        config.base_config.warmup_iterations = warmup_iterations;
        config.base_config.iterations = iterations;
        config
    }

    #[test]
    fn test_benchmark_stability_reports_real_timing() {
        // `benchmark_stability` must measure the real execution time of `mean`,
        // not return the old fabricated `mean_ns: 1000.0` constant.
        let suite = AdvancedBenchmarkSuite::new(fast_config(2, 8));
        let data = Array1::from_elem(1000, 3.5_f64);

        let metrics = suite
            .benchmark_stability("mean_stability_real", &data)
            .expect("stability benchmark should succeed with iterations > 0");

        // Real measurement: a positive, finite wall-clock mean derived from the
        // measured samples (ordering of percentiles is internally consistent).
        let timing = &metrics.base_metrics.timing;
        assert!(timing.mean_ns > 0.0, "measured mean must be positive");
        assert!(timing.mean_ns.is_finite());
        assert!(timing.min_ns <= timing.mean_ns);
        assert!(timing.mean_ns <= timing.max_ns);
        assert_eq!(metrics.base_metrics.function_name, "mean_stability_real");
        assert_eq!(metrics.base_metrics.datasize, 1000);
    }

    #[test]
    fn test_benchmark_stability_honest_error_on_zero_iterations() {
        // With zero measurement iterations there is nothing real to report, so
        // an honest error must be returned rather than fabricated timings.
        let suite = AdvancedBenchmarkSuite::new(fast_config(0, 0));
        let data = Array1::from_elem(100, 1.0_f64);

        let err = suite
            .benchmark_stability("mean_stability_empty", &data)
            .expect_err("zero iterations must yield an honest error, not fake data");
        assert!(matches!(err, StatsError::InvalidArgument(_)));
    }

    #[test]
    fn test_benchmark_cross_platform_reports_current_platform_only() {
        // A single process can only observe its own architecture. The result
        // must contain a real measured timing keyed by the current ARCH, not the
        // old fabricated per-platform constants (x86_64/aarch64/wasm32).
        let suite = AdvancedBenchmarkSuite::new(fast_config(2, 8));
        let data = Array1::from_elem(1000, 2.0_f64);

        let metrics = suite
            .benchmark_cross_platform("mean_cross_platform_real", &data)
            .expect("cross-platform benchmark should succeed with iterations > 0");

        let variance = metrics
            .platform_variance
            .expect("platform variance must be present");

        // Exactly one observable platform: the current architecture.
        assert_eq!(variance.platform_specific_metrics.len(), 1);
        let arch = std::env::consts::ARCH;
        let measured = variance
            .platform_specific_metrics
            .get(arch)
            .copied()
            .expect("current architecture must be reported");
        assert!(measured > 0.0, "reported timing must be a real measurement");

        // CV is the real intra-platform jitter (non-negative, finite).
        assert!(variance.coefficient_of_variation >= 0.0);
        assert!(variance.coefficient_of_variation.is_finite());

        // No fabricated per-target feature impacts.
        assert!(variance
            .feature_dependency_analysis
            .simd_feature_impact
            .is_empty());
    }

    #[test]
    fn test_benchmark_cross_platform_honest_error_on_zero_iterations() {
        let suite = AdvancedBenchmarkSuite::new(fast_config(0, 0));
        let data = Array1::from_elem(100, 1.0_f64);

        let err = suite
            .benchmark_cross_platform("mean_cross_platform_empty", &data)
            .expect_err("zero iterations must yield an honest error, not fake data");
        assert!(matches!(err, StatsError::InvalidArgument(_)));
    }
}