foxhunt/ml/src/risk/extreme_value_models.rs

//! Extreme Value Theory (EVT) Integration with Machine Learning
//!
//! Implements ML-enhanced extreme value models for tail risk estimation and extreme
//! event modeling. Combines classical EVT with neural networks for dynamic parameter
//! estimation and regime-dependent tail behavior modeling.
//!
//! # Features
//! - Generalized Extreme Value (GEV) distribution modeling
//! - Generalized Pareto Distribution (GPD) for peaks-over-threshold
//! - Neural network-based parameter estimation
//! - Time-varying EVT parameters with regime detection
//! - Extreme quantile estimation with uncertainty
//! - Tail risk measures: VaR, Expected Shortfall, Tail Value-at-Risk
//! - Block maxima and peaks-over-threshold approaches
//!
//! # Performance Targets
//! - Parameter estimation: <1ms
//! - Extreme quantile calculation: <100μs
//! - Real-time threshold updates: <200μs
//! - Memory efficiency: <64MB for large datasets

use std::sync::Arc;

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};

use super::*;
// use crate::safe_operations; // DISABLED - module not found

    #[test]
    fn test_neural_evt_model_creation() {
        let config = EVTModelConfig::default();
        let distribution = ExtremeValueDistribution::GEV {
            location: 0.0,
            scale: 1.0,
            shape: 0.1,
        };
        
        let model = NeuralEVTModel::new(distribution, config);
        
        assert_eq!(model.parameter_network.architecture.output_size, 3); // GEV has 3 parameters
        assert!(model.parameter_history.is_empty());
    }
    
    #[test]
    fn test_block_maxima_extraction() {
        let config = EVTModelConfig {
            block_size: 5,
            ..Default::default()
        };
        let distribution = ExtremeValueDistribution::GEV {
            location: 0.0,
            scale: 1.0,
            shape: 0.0,
        };
        let model = NeuralEVTModel::new(distribution, config);
        
        let data = vec![1.0, 3.0, 2.0, 5.0, 1.0, 2.0, 4.0, 1.0, 3.0, 2.0];
        let maxima = model.extract_block_maxima(&data);
        
        assert_eq!(maxima.len(), 2);
        assert_eq!(maxima[0], 5.0);
        assert_eq!(maxima[1], 4.0);
    }
    
    #[test]
    fn test_threshold_estimation_and_exceedances() {
        let config = EVTModelConfig {
            threshold_quantile: 0.8,
            ..Default::default()
        };
        let distribution = ExtremeValueDistribution::GPD {
            scale: 1.0,
            shape: 0.1,
            threshold: 0.0,
        };
        let model = NeuralEVTModel::new(distribution, config);
        
        let data = vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0];
        let threshold = model.estimate_threshold(&data);
        let exceedances = model.extract_exceedances(&data, threshold);
        
        assert!(threshold > 8.0); // 80th percentile should be around 8.8
        assert!(exceedances.len() <= 2); // Only values above threshold
    }
    
    #[test]
    fn test_parameter_constraints() {
        let config = EVTModelConfig::default();
        let distribution = ExtremeValueDistribution::GEV {
            location: 0.0,
            scale: 1.0,
            shape: 0.0,
        };
        let model = NeuralEVTModel::new(distribution, config);
        
        // Test GEV parameter constraints
        let raw_params = vec![-1.0, -0.5, 2.0]; // location, scale, shape
        let constrained = model.constrain_parameters(raw_params);
        
        assert_eq!(constrained[0], -1.0); // location unconstrained
        assert!(constrained[1] > 0.0); // scale must be positive
        assert!(constrained[2] >= -0.5 && constrained[2] <= 0.5); // shape bounded
    }
    
    #[test]
    fn test_quantile_calculation() {
        let config = EVTModelConfig::default();
        let distribution = ExtremeValueDistribution::Gumbel {
            location: 0.0,
            scale: 1.0,
        };
        let model = NeuralEVTModel::new(distribution, config);
        
        let parameters = vec![0.0, 1.0]; // location, scale
        let quantile_99 = model.calculate_quantile(0.99, &parameters, None);
        
        // For Gumbel(0,1), 99th percentile should be approximately 4.6
        assert!(quantile_99 > 4.0 && quantile_99 < 5.0);
    }
    
    #[test]
    fn test_parameter_estimation_with_sufficient_data() {
        let config = EVTModelConfig {
            min_exceedances: 10,
            ..Default::default()
        };
        let distribution = ExtremeValueDistribution::GPD {
            scale: 1.0,
            shape: 0.1,
            threshold: 0.0,
        };
        let mut model = NeuralEVTModel::new(distribution, config);
        
        // Generate data with enough exceedances
        let data: Vec<f32> = (0..1000)
            .map(|i| (i as f32 / 100.0).exp()) // Exponential-like data
            .collect();
        
        let result = model.estimate_parameters(&data);
        
        assert!(result.is_ok());
        let parameters = result?;
        assert_eq!(parameters.parameters.len(), 2); // GPD has 2 parameters
        assert!(parameters.threshold.is_some());
        assert!(parameters.n_exceedances.is_some());
    }
    
    #[test]
    fn test_extreme_quantile_calculation() {
        let config = EVTModelConfig {
            mc_samples: 100, // Reduced for test speed
            ..Default::default()
        };
        let distribution = ExtremeValueDistribution::GEV {
            location: 0.0,
            scale: 1.0,
            shape: 0.1,
        };
        let model = NeuralEVTModel::new(distribution, config);
        
        let parameters = EVTParameters {
            parameters: vec![0.0, 1.0, 0.1],
            confidence_intervals: vec![(-0.1, 0.1), (0.9, 1.1), (0.05, 0.15)],
            threshold: None,
            n_exceedances: None,
            gof_statistics: EVTGoodnessOfFit {
                anderson_darling: 0.5,
                kolmogorov_smirnov: 0.08,
                cramer_von_mises: 0.12,
                p_value: 0.25,
                aic: 100.0,
                bic: 105.0,
            },
            tail_index: 0.1,
            return_levels: vec![],
            timestamp: Utc::now().timestamp_nanos_opt().unwrap_or(0) as u64,
            confidence_score: 0.8,
        };
        
        let probabilities = vec![0.99, 0.995, 0.999];
        let quantiles = model.calculate_extreme_quantiles(&probabilities, &parameters);
        
        assert_eq!(quantiles.len(), 3);
        
        // Check that extreme quantiles are increasing
        assert!(quantiles[0].value < quantiles[1].value);
        assert!(quantiles[1].value < quantiles[2].value);
        
        // Check that return periods are reasonable
        assert!(quantiles[0].return_period < quantiles[1].return_period);
        assert!(quantiles[2].return_period > 1000.0); // 99.9th percentile
    }
    
    #[test]
    fn test_performance_requirements() {
        let config = EVTModelConfig {
            mc_samples: 100, // Reduced for performance test
            ..Default::default()
        };
        let distribution = ExtremeValueDistribution::GEV {
            location: 0.0,
            scale: 1.0,
            shape: 0.1,
        };
        let mut model = NeuralEVTModel::new(distribution, config);
        
        // Generate test data
        let data: Vec<f32> = (0..1000).map(|i| (i as f32).sin()).collect();
        
        let start = std::time::Instant::now();
        let result = model.estimate_parameters(&data);
        let estimation_time = start.elapsed();
        
        // Should complete parameter estimation in <1ms
        assert!(estimation_time.as_millis() < 1);
        assert!(result.is_ok());
        
        let parameters = result?;
        
        let start = std::time::Instant::now();
        let quantiles = model.calculate_extreme_quantiles(&[0.99], &parameters);
        let quantile_time = start.elapsed();
        
        // Should complete quantile calculation in <100μs
        assert!(quantile_time.as_micros() < 100);
        assert_eq!(quantiles.len(), 1);
    }