foxhunt/tests/integration/ml_trading_integration.rs

//! ML Models ↔ Trading Integration Tests
//!
//! This module provides comprehensive integration testing between the ML models
//! and the core Trading system. Tests cover:
//!
//! ## Test Coverage Areas
//! - TLOB transformer predictions → trading decisions
//! - MAMBA-2 SSM real-time inference integration
//! - DQN/PPO RL agent position sizing
//! - Model ensemble voting and confidence scoring
//! - Fallback to traditional indicators on ML failure
//! - Real-time inference latency under HFT requirements
//! - Model prediction accuracy and consistency
//! - GPU/CPU inference pipeline validation
//!
//! ## Architecture Under Test
//! ```
//! Market Data → ML Models → Trading Signals → Order Management
//!      ↓           ↓              ↓              ↓
//!   Polygon.io  TLOB/MAMBA    Confidence     Risk Check
//!      ↓           ↓              ↓              ↓
//!    Features   Predictions   Signal Gen.   Execution
//! ```

use std::collections::HashMap;
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::{RwLock, mpsc, Mutex};
use tokio::time::timeout;
use uuid::Uuid;

// Import core system types
use trading_engine::timing::HardwareTimestamp;
use ml::prelude::*;
use ml::tlob_transformer::*;
use ml::mamba::*;
use ml::dqn::*;
use ml::ppo::*;

/// Test result type for safe error handling
type TestResult<T> = Result<T, Box<dyn std::error::Error + Send + Sync>>;

/// ML-Trading integration test configuration
#[derive(Debug, Clone)]
pub struct MlTradingIntegrationConfig {
    /// Maximum inference latency for HFT (microseconds)
    pub max_inference_latency_us: u64,
    /// Maximum end-to-end ML pipeline latency (milliseconds)
    pub max_ml_pipeline_latency_ms: u64,
    /// Minimum prediction confidence threshold
    pub min_prediction_confidence: f64,
    /// Test symbols for ML model validation
    pub test_symbols: Vec<String>,
    /// Number of test iterations for performance validation
    pub performance_test_iterations: usize,
    /// Enable GPU inference if available
    pub enable_gpu_inference: bool,
    /// Model ensemble weights
    pub ensemble_weights: HashMap<String, f64>,
    /// Fallback to traditional indicators threshold
    pub fallback_confidence_threshold: f64,
}

impl Default for MlTradingIntegrationConfig {
    fn default() -> Self {
        let mut ensemble_weights = HashMap::new();
        ensemble_weights.insert("tlob_transformer".to_string(), 0.4);
        ensemble_weights.insert("mamba_ssm".to_string(), 0.3);
        ensemble_weights.insert("dqn_agent".to_string(), 0.2);
        ensemble_weights.insert("ppo_agent".to_string(), 0.1);

        Self {
            max_inference_latency_us: 10_000,  // 10ms for HFT
            max_ml_pipeline_latency_ms: 50,    // 50ms total pipeline
            min_prediction_confidence: 0.7,   // 70% minimum confidence
            test_symbols: vec!["EURUSD".to_string(), "GBPUSD".to_string(), "USDJPY".to_string()],
            performance_test_iterations: 1000,
            enable_gpu_inference: true,
            ensemble_weights,
            fallback_confidence_threshold: 0.5,  // Fallback below 50%
        }
    }
}

/// ML-Trading integration test suite
pub struct MlTradingIntegrationSuite {
    config: MlTradingIntegrationConfig,
    tlob_model: Arc<TlobTransformer>,
    mamba_model: Arc<MambaSSM>,
    dqn_agent: Arc<DqnAgent>,
    ppo_agent: Arc<PpoAgent>,
    ensemble_coordinator: Arc<ModelEnsemble>,
    signal_generator: Arc<TradingSignalGenerator>,
    performance_tracker: Arc<MlPerformanceTracker>,
    feature_pipeline: Arc<FeaturePipeline>,
}

impl MlTradingIntegrationSuite {
    /// Create new ML-Trading integration test suite
    pub async fn new(config: MlTradingIntegrationConfig) -> TestResult<Self> {
        // Initialize ML models
        let tlob_model = Arc::new(
            TlobTransformer::load_pretrained("models/tlob_transformer_v2.bin").await
                .map_err(|e| format!("Failed to load TLOB model: {}", e))?
        );

        let mamba_model = Arc::new(
            MambaSSM::load_pretrained("models/mamba_ssm_v1.bin").await
                .map_err(|e| format!("Failed to load MAMBA model: {}", e))?
        );

        let dqn_agent = Arc::new(
            DqnAgent::load_pretrained("models/dqn_agent_v3.bin").await
                .map_err(|e| format!("Failed to load DQN agent: {}", e))?
        );

        let ppo_agent = Arc::new(
            PpoAgent::load_pretrained("models/ppo_agent_v2.bin").await
                .map_err(|e| format!("Failed to load PPO agent: {}", e))?
        );

        // Configure model ensemble
        let ensemble_coordinator = Arc::new(
            ModelEnsemble::new(config.ensemble_weights.clone())
        );

        // Initialize signal generation pipeline
        let signal_generator = Arc::new(
            TradingSignalGenerator::new(config.min_prediction_confidence)
        );

        let performance_tracker = Arc::new(MlPerformanceTracker::new());
        let feature_pipeline = Arc::new(FeaturePipeline::new());

        Ok(Self {
            config,
            tlob_model,
            mamba_model,
            dqn_agent,
            ppo_agent,
            ensemble_coordinator,
            signal_generator,
            performance_tracker,
            feature_pipeline,
        })
    }

    /// Test TLOB transformer predictions and trading integration
    pub async fn test_tlob_transformer_integration(&self) -> TestResult<()> {
        let mut total_latency = 0u64;
        let mut successful_predictions = 0usize;

        for symbol in &self.config.test_symbols {
            // Generate test market data
            let market_data = self.generate_test_market_data(symbol).await?;
            
            for data_point in market_data.iter().take(100) {
                let start_time = HardwareTimestamp::now();

                // Extract features for TLOB model
                let features = self.feature_pipeline
                    .extract_tlob_features(data_point)
                    .await
                    .map_err(|e| format!("Feature extraction failed: {}", e))?;

                // Run TLOB inference
                let prediction = self.tlob_model
                    .predict(&features)
                    .await
                    .map_err(|e| format!("TLOB prediction failed: {}", e))?;

                let inference_latency = HardwareTimestamp::now().latency_ns(&start_time);
                total_latency += inference_latency;

                // Validate inference latency
                assert!(
                    inference_latency < self.config.max_inference_latency_us * 1_000,
                    "TLOB inference latency {}μs exceeds requirement {}μs",
                    inference_latency / 1_000,
                    self.config.max_inference_latency_us
                );

                // Validate prediction structure
                assert!(
                    prediction.confidence >= 0.0 && prediction.confidence <= 1.0,
                    "TLOB confidence should be between 0 and 1"
                );

                assert!(
                    prediction.direction_probability.len() == 3, // Up, Down, Sideways
                    "TLOB should predict 3 direction probabilities"
                );

                // Generate trading signal from TLOB prediction
                let trading_signal = self.signal_generator
                    .generate_signal_from_tlob(&prediction, symbol)
                    .await?;

                if trading_signal.is_actionable() {
                    successful_predictions += 1;
                }

                self.performance_tracker
                    .record_tlob_inference(inference_latency / 1_000)
                    .await;
            }
        }

        let avg_latency = total_latency / (self.config.test_symbols.len() * 100) as u64;
        let success_rate = successful_predictions as f64 / (self.config.test_symbols.len() * 100) as f64;

        assert!(
            success_rate >= 0.3, // At least 30% actionable signals
            "TLOB success rate {:.1}% should be >= 30%",
            success_rate * 100.0
        );

        println!("✓ TLOB transformer integration test passed:");
        println!("  Average latency: {}μs", avg_latency / 1_000);
        println!("  Success rate: {:.1}%", success_rate * 100.0);
        println!("  Symbols tested: {}", self.config.test_symbols.len());

        Ok(())
    }

    /// Test MAMBA-2 SSM real-time inference integration
    pub async fn test_mamba_ssm_integration(&self) -> TestResult<()> {
        let mut total_latency = 0u64;
        let mut prediction_consistency = Vec::new();

        for symbol in &self.config.test_symbols {
            let market_data = self.generate_test_market_data(symbol).await?;
            let mut previous_prediction: Option<MambaPrediction> = None;

            for data_point in market_data.iter().take(100) {
                let start_time = HardwareTimestamp::now();

                // Extract sequential features for MAMBA
                let features = self.feature_pipeline
                    .extract_mamba_features(data_point)
                    .await?;

                // Run MAMBA inference with state management
                let prediction = self.mamba_model
                    .predict_with_state(&features)
                    .await
                    .map_err(|e| format!("MAMBA prediction failed: {}", e))?;

                let inference_latency = HardwareTimestamp::now().latency_ns(&start_time);
                total_latency += inference_latency;

                // Validate inference latency
                assert!(
                    inference_latency < self.config.max_inference_latency_us * 1_000,
                    "MAMBA inference latency {}μs exceeds requirement {}μs",
                    inference_latency / 1_000,
                    self.config.max_inference_latency_us
                );

                // Validate state consistency
                if let Some(prev_pred) = &previous_prediction {
                    let consistency = self.calculate_prediction_consistency(prev_pred, &prediction);
                    prediction_consistency.push(consistency);
                }

                // Validate prediction structure
                assert!(
                    prediction.price_target.is_finite(),
                    "MAMBA price target should be finite"
                );

                assert!(
                    prediction.volatility_forecast > 0.0,
                    "MAMBA volatility forecast should be positive"
                );

                previous_prediction = Some(prediction.clone());

                self.performance_tracker
                    .record_mamba_inference(inference_latency / 1_000)
                    .await;
            }
        }

        let avg_latency = total_latency / (self.config.test_symbols.len() * 100) as u64;
        let avg_consistency = if !prediction_consistency.is_empty() {
            prediction_consistency.iter().sum::<f64>() / prediction_consistency.len() as f64
        } else { 0.0 };

        assert!(
            avg_consistency >= 0.7, // At least 70% consistency
            "MAMBA prediction consistency {:.1}% should be >= 70%",
            avg_consistency * 100.0
        );

        println!("✓ MAMBA-2 SSM integration test passed:");
        println!("  Average latency: {}μs", avg_latency / 1_000);
        println!("  Prediction consistency: {:.1}%", avg_consistency * 100.0);
        println!("  State continuity maintained across predictions");

        Ok(())
    }

    /// Test DQN/PPO RL agent position sizing integration
    pub async fn test_rl_agents_integration(&self) -> TestResult<()> {
        let mut dqn_actions = Vec::new();
        let mut ppo_actions = Vec::new();

        for symbol in &self.config.test_symbols {
            let market_data = self.generate_test_market_data(symbol).await?;

            for data_point in market_data.iter().take(50) {
                // Test DQN agent
                let dqn_start = HardwareTimestamp::now();
                
                let dqn_state = self.feature_pipeline
                    .extract_rl_state(data_point)
                    .await?;

                let dqn_action = self.dqn_agent
                    .select_action(&dqn_state)
                    .await
                    .map_err(|e| format!("DQN action selection failed: {}", e))?;

                let dqn_latency = HardwareTimestamp::now().latency_ns(&dqn_start);

                // Test PPO agent
                let ppo_start = HardwareTimestamp::now();
                
                let ppo_action = self.ppo_agent
                    .select_action(&dqn_state) // Same state representation
                    .await
                    .map_err(|e| format!("PPO action selection failed: {}", e))?;

                let ppo_latency = HardwareTimestamp::now().latency_ns(&ppo_start);

                // Validate RL inference latencies
                assert!(
                    dqn_latency < self.config.max_inference_latency_us * 1_000,
                    "DQN inference latency {}μs exceeds requirement {}μs",
                    dqn_latency / 1_000,
                    self.config.max_inference_latency_us
                );

                assert!(
                    ppo_latency < self.config.max_inference_latency_us * 1_000,
                    "PPO inference latency {}μs exceeds requirement {}μs",
                    ppo_latency / 1_000,
                    self.config.max_inference_latency_us
                );

                // Validate action values
                assert!(
                    dqn_action.position_size >= -1.0 && dqn_action.position_size <= 1.0,
                    "DQN position size should be normalized"
                );

                assert!(
                    ppo_action.position_size >= -1.0 && ppo_action.position_size <= 1.0,
                    "PPO position size should be normalized"
                );

                dqn_actions.push(dqn_action);
                ppo_actions.push(ppo_action);

                self.performance_tracker
                    .record_dqn_inference(dqn_latency / 1_000)
                    .await;
                
                self.performance_tracker
                    .record_ppo_inference(ppo_latency / 1_000)
                    .await;
            }
        }

        // Validate action diversity (agents shouldn't always predict the same action)
        let dqn_action_variance = self.calculate_action_variance(&dqn_actions);
        let ppo_action_variance = self.calculate_action_variance(&ppo_actions);

        assert!(
            dqn_action_variance > 0.01,
            "DQN actions should show diversity, variance: {:.4}",
            dqn_action_variance
        );

        assert!(
            ppo_action_variance > 0.01,
            "PPO actions should show diversity, variance: {:.4}",
            ppo_action_variance
        );

        println!("✓ RL agents integration test passed:");
        println!("  DQN actions generated: {}", dqn_actions.len());
        println!("  PPO actions generated: {}", ppo_actions.len());
        println!("  DQN action variance: {:.4}", dqn_action_variance);
        println!("  PPO action variance: {:.4}", ppo_action_variance);

        Ok(())
    }

    /// Test model ensemble voting and confidence scoring
    pub async fn test_model_ensemble_integration(&self) -> TestResult<()> {
        let mut ensemble_predictions = Vec::new();

        for symbol in &self.config.test_symbols {
            let market_data = self.generate_test_market_data(symbol).await?;

            for data_point in market_data.iter().take(50) {
                let start_time = HardwareTimestamp::now();

                // Get predictions from all models
                let tlob_features = self.feature_pipeline.extract_tlob_features(data_point).await?;
                let mamba_features = self.feature_pipeline.extract_mamba_features(data_point).await?;
                let rl_state = self.feature_pipeline.extract_rl_state(data_point).await?;

                let tlob_pred = self.tlob_model.predict(&tlob_features).await?;
                let mamba_pred = self.mamba_model.predict_with_state(&mamba_features).await?;
                let dqn_action = self.dqn_agent.select_action(&rl_state).await?;
                let ppo_action = self.ppo_agent.select_action(&rl_state).await?;

                // Combine predictions through ensemble
                let ensemble_result = self.ensemble_coordinator
                    .combine_predictions(
                        &tlob_pred,
                        &mamba_pred,
                        &dqn_action,
                        &ppo_action,
                    )
                    .await
                    .map_err(|e| format!("Ensemble combination failed: {}", e))?;

                let ensemble_latency = HardwareTimestamp::now().latency_ns(&start_time);

                // Validate ensemble latency
                assert!(
                    ensemble_latency < self.config.max_ml_pipeline_latency_ms * 1_000_000,
                    "Ensemble pipeline latency {}ms exceeds requirement {}ms",
                    ensemble_latency / 1_000_000,
                    self.config.max_ml_pipeline_latency_ms
                );

                // Validate ensemble result structure
                assert!(
                    ensemble_result.confidence >= 0.0 && ensemble_result.confidence <= 1.0,
                    "Ensemble confidence should be between 0 and 1"
                );

                assert!(
                    ensemble_result.weight_distribution.len() == 4, // All 4 models
                    "Ensemble should include all model weights"
                );

                let weight_sum: f64 = ensemble_result.weight_distribution.values().sum();
                assert!(
                    (weight_sum - 1.0).abs() < 0.01,
                    "Ensemble weights should sum to 1.0, got {:.3}",
                    weight_sum
                );

                ensemble_predictions.push(ensemble_result);

                self.performance_tracker
                    .record_ensemble_inference(ensemble_latency / 1_000)
                    .await;
            }
        }

        // Validate ensemble performance
        let high_confidence_predictions = ensemble_predictions
            .iter()
            .filter(|p| p.confidence >= self.config.min_prediction_confidence)
            .count();

        let high_confidence_rate = high_confidence_predictions as f64 / ensemble_predictions.len() as f64;

        assert!(
            high_confidence_rate >= 0.2, // At least 20% high-confidence predictions
            "High confidence rate {:.1}% should be >= 20%",
            high_confidence_rate * 100.0
        );

        println!("✓ Model ensemble integration test passed:");
        println!("  Total ensemble predictions: {}", ensemble_predictions.len());
        println!("  High confidence predictions: {} ({:.1}%)", 
                 high_confidence_predictions, high_confidence_rate * 100.0);
        println!("  Model weights balanced and normalized");

        Ok(())
    }

    /// Test fallback to traditional indicators on ML failure
    pub async fn test_fallback_mechanism(&self) -> TestResult<()> {
        let mut fallback_activations = 0;
        let mut fallback_signals = Vec::new();

        for symbol in &self.config.test_symbols {
            let market_data = self.generate_test_market_data(symbol).await?;

            for data_point in market_data.iter().take(50) {
                // Simulate ML model failure scenarios
                let ml_available = rand::random::<f64>() > 0.3; // 30% failure rate

                let trading_signal = if ml_available {
                    // Normal ML prediction path
                    let features = self.feature_pipeline.extract_tlob_features(data_point).await?;
                    let prediction = self.tlob_model.predict(&features).await?;
                    
                    if prediction.confidence >= self.config.fallback_confidence_threshold {
                        self.signal_generator.generate_signal_from_tlob(&prediction, symbol).await?
                    } else {
                        // Low confidence - fallback to traditional
                        fallback_activations += 1;
                        self.signal_generator.generate_traditional_signal(data_point, symbol).await?
                    }
                } else {
                    // ML failure - fallback to traditional
                    fallback_activations += 1;
                    self.signal_generator.generate_traditional_signal(data_point, symbol).await?
                };

                fallback_signals.push(trading_signal);
            }
        }

        let total_signals = self.config.test_symbols.len() * 50;
        let fallback_rate = fallback_activations as f64 / total_signals as f64;

        // Validate fallback mechanism
        assert!(
            fallback_rate > 0.0,
            "Fallback mechanism should activate during testing"
        );

        assert!(
            fallback_rate < 0.8, // Should not fallback too frequently
            "Fallback rate {:.1}% should be < 80%",
            fallback_rate * 100.0
        );

        // Validate that fallback signals are still actionable
        let actionable_fallback_signals = fallback_signals
            .iter()
            .filter(|s| s.is_actionable())
            .count();

        let actionable_rate = actionable_fallback_signals as f64 / fallback_signals.len() as f64;

        assert!(
            actionable_rate >= 0.3, // At least 30% actionable even with fallback
            "Actionable signal rate {:.1}% should be >= 30%",
            actionable_rate * 100.0
        );

        println!("✓ Fallback mechanism test passed:");
        println!("  Fallback activations: {} ({:.1}%)", 
                 fallback_activations, fallback_rate * 100.0);
        println!("  Actionable signals: {} ({:.1}%)", 
                 actionable_fallback_signals, actionable_rate * 100.0);
        println!("  Robust operation under ML failures");

        Ok(())
    }

    /// Test real-time inference performance under HFT requirements
    pub async fn test_hft_performance_requirements(&self) -> TestResult<()> {
        let mut all_latencies = Vec::new();
        let test_iterations = self.config.performance_test_iterations;

        // Generate test data for performance testing
        let test_data = self.generate_test_market_data(&"EURUSD".to_string()).await?;
        
        for i in 0..test_iterations {
            let data_point = &test_data[i % test_data.len()];
            let start_time = HardwareTimestamp::now();

            // Full ML pipeline execution
            let features = self.feature_pipeline.extract_tlob_features(data_point).await?;
            let prediction = self.tlob_model.predict(&features).await?;
            let signal = self.signal_generator.generate_signal_from_tlob(&prediction, "EURUSD").await?;

            let total_latency = HardwareTimestamp::now().latency_ns(&start_time);
            all_latencies.push(total_latency);

            // Validate individual iteration latency
            assert!(
                total_latency < self.config.max_ml_pipeline_latency_ms * 1_000_000,
                "ML pipeline latency {}μs exceeds requirement {}ms",
                total_latency / 1_000,
                self.config.max_ml_pipeline_latency_ms
            );
        }

        // Calculate performance statistics
        let avg_latency = all_latencies.iter().sum::<u64>() / all_latencies.len() as u64;
        let max_latency = *all_latencies.iter().max().unwrap();
        let min_latency = *all_latencies.iter().min().unwrap();

        // Calculate percentiles
        let mut sorted_latencies = all_latencies.clone();
        sorted_latencies.sort_unstable();
        let p95_latency = sorted_latencies[sorted_latencies.len() * 95 / 100];
        let p99_latency = sorted_latencies[sorted_latencies.len() * 99 / 100];

        // HFT performance requirements
        assert!(
            avg_latency < self.config.max_inference_latency_us * 1_000,
            "Average ML latency {}μs exceeds HFT requirement {}μs",
            avg_latency / 1_000,
            self.config.max_inference_latency_us
        );

        assert!(
            p95_latency < self.config.max_inference_latency_us * 2 * 1_000,
            "P95 ML latency {}μs exceeds acceptable threshold {}μs",
            p95_latency / 1_000,
            self.config.max_inference_latency_us * 2
        );

        println!("✓ HFT performance requirements test passed:");
        println!("  Test iterations: {}", test_iterations);
        println!("  Average latency: {}μs", avg_latency / 1_000);
        println!("  P95 latency: {}μs", p95_latency / 1_000);
        println!("  P99 latency: {}μs", p99_latency / 1_000);
        println!("  Max latency: {}μs", max_latency / 1_000);
        println!("  Min latency: {}μs", min_latency / 1_000);

        Ok(())
    }

    /// Helper methods
    async fn generate_test_market_data(&self, symbol: &str) -> TestResult<Vec<MarketDataPoint>> {
        let mut data_points = Vec::new();
        let base_price = 1.1000; // Base price for EURUSD

        for i in 0..1000 {
            let price = base_price + (i as f64 * 0.0001 * (i as f64 / 100.0).sin());
            let volume = 1000 + (i * 10) % 5000;

            data_points.push(MarketDataPoint {
                symbol: symbol.to_string(),
                timestamp: HardwareTimestamp::now(),
                bid: Decimal::try_from(price - 0.0001).unwrap(),
                ask: Decimal::try_from(price + 0.0001).unwrap(),
                last: Decimal::try_from(price).unwrap(),
                volume: volume as u64,
                spread: Decimal::try_from(0.0002).unwrap(),
            });
        }

        Ok(data_points)
    }

    fn calculate_prediction_consistency(&self, prev: &MambaPrediction, current: &MambaPrediction) -> f64 {
        let price_diff = (prev.price_target - current.price_target).abs();
        let vol_diff = (prev.volatility_forecast - current.volatility_forecast).abs();
        
        // Simple consistency metric (1.0 = identical, 0.0 = completely different)
        let price_consistency = 1.0 - (price_diff / prev.price_target).min(1.0);
        let vol_consistency = 1.0 - (vol_diff / prev.volatility_forecast).min(1.0);
        
        (price_consistency + vol_consistency) / 2.0
    }

    fn calculate_action_variance(&self, actions: &[RlAction]) -> f64 {
        if actions.is_empty() {
            return 0.0;
        }

        let mean = actions.iter().map(|a| a.position_size).sum::<f64>() / actions.len() as f64;
        let variance = actions.iter()
            .map(|a| (a.position_size - mean).powi(2))
            .sum::<f64>() / actions.len() as f64;
        
        variance
    }

    /// Get comprehensive performance statistics
    pub async fn get_performance_stats(&self) -> MlPerformanceStats {
        self.performance_tracker.get_stats().await
    }
}

/// Performance tracking for ML-Trading integration
#[derive(Debug)]
pub struct MlPerformanceTracker {
    tlob_latencies: RwLock<Vec<u64>>,
    mamba_latencies: RwLock<Vec<u64>>,
    dqn_latencies: RwLock<Vec<u64>>,
    ppo_latencies: RwLock<Vec<u64>>,
    ensemble_latencies: RwLock<Vec<u64>>,
}

impl MlPerformanceTracker {
    pub fn new() -> Self {
        Self {
            tlob_latencies: RwLock::new(Vec::new()),
            mamba_latencies: RwLock::new(Vec::new()),
            dqn_latencies: RwLock::new(Vec::new()),
            ppo_latencies: RwLock::new(Vec::new()),
            ensemble_latencies: RwLock::new(Vec::new()),
        }
    }

    pub async fn record_tlob_inference(&self, latency_us: u64) {
        self.tlob_latencies.write().await.push(latency_us);
    }

    pub async fn record_mamba_inference(&self, latency_us: u64) {
        self.mamba_latencies.write().await.push(latency_us);
    }

    pub async fn record_dqn_inference(&self, latency_us: u64) {
        self.dqn_latencies.write().await.push(latency_us);
    }

    pub async fn record_ppo_inference(&self, latency_us: u64) {
        self.ppo_latencies.write().await.push(latency_us);
    }

    pub async fn record_ensemble_inference(&self, latency_us: u64) {
        self.ensemble_latencies.write().await.push(latency_us);
    }

    pub async fn get_stats(&self) -> MlPerformanceStats {
        let tlob_lats = self.tlob_latencies.read().await;
        let mamba_lats = self.mamba_latencies.read().await;
        let dqn_lats = self.dqn_latencies.read().await;
        let ppo_lats = self.ppo_latencies.read().await;
        let ensemble_lats = self.ensemble_latencies.read().await;

        MlPerformanceStats {
            avg_tlob_latency_us: if !tlob_lats.is_empty() {
                tlob_lats.iter().sum::<u64>() / tlob_lats.len() as u64
            } else { 0 },
            avg_mamba_latency_us: if !mamba_lats.is_empty() {
                mamba_lats.iter().sum::<u64>() / mamba_lats.len() as u64
            } else { 0 },
            avg_dqn_latency_us: if !dqn_lats.is_empty() {
                dqn_lats.iter().sum::<u64>() / dqn_lats.len() as u64
            } else { 0 },
            avg_ppo_latency_us: if !ppo_lats.is_empty() {
                ppo_lats.iter().sum::<u64>() / ppo_lats.len() as u64
            } else { 0 },
            avg_ensemble_latency_us: if !ensemble_lats.is_empty() {
                ensemble_lats.iter().sum::<u64>() / ensemble_lats.len() as u64
            } else { 0 },
            total_tlob_inferences: tlob_lats.len(),
            total_mamba_inferences: mamba_lats.len(),
            total_dqn_inferences: dqn_lats.len(),
            total_ppo_inferences: ppo_lats.len(),
            total_ensemble_inferences: ensemble_lats.len(),
        }
    }
}

#[derive(Debug, Clone)]
pub struct MlPerformanceStats {
    pub avg_tlob_latency_us: u64,
    pub avg_mamba_latency_us: u64,
    pub avg_dqn_latency_us: u64,
    pub avg_ppo_latency_us: u64,
    pub avg_ensemble_latency_us: u64,
    pub total_tlob_inferences: usize,
    pub total_mamba_inferences: usize,
    pub total_dqn_inferences: usize,
    pub total_ppo_inferences: usize,
    pub total_ensemble_inferences: usize,
}

// Mock types for compilation (these would be defined in the ML modules)
#[derive(Debug, Clone)]
pub struct MarketDataPoint {
    pub symbol: String,
    pub timestamp: HardwareTimestamp,
    pub bid: Decimal,
    pub ask: Decimal,
    pub last: Decimal,
    pub volume: u64,
    pub spread: Decimal,
}

#[derive(Debug, Clone)]
pub struct TlobPrediction {
    pub confidence: f64,
    pub direction_probability: Vec<f64>,
}

#[derive(Debug, Clone)]
pub struct MambaPrediction {
    pub price_target: f64,
    pub volatility_forecast: f64,
}

#[derive(Debug, Clone)]
pub struct RlAction {
    pub position_size: f64,
}

#[derive(Debug, Clone)]
pub struct EnsembleResult {
    pub confidence: f64,
    pub weight_distribution: HashMap<String, f64>,
}

#[derive(Debug, Clone)]
pub struct TradingSignal {
    pub action: String,
    pub confidence: f64,
    pub size: f64,
}

impl TradingSignal {
    pub fn is_actionable(&self) -> bool {
        self.confidence > 0.5
    }
}

// Mock implementations (these would be real implementations in the ML modules)
pub struct TlobTransformer;
pub struct MambaSSM;
pub struct DqnAgent;
pub struct PpoAgent;
pub struct ModelEnsemble;
pub struct TradingSignalGenerator;
pub struct FeaturePipeline;

impl TlobTransformer {
    pub async fn load_pretrained(_path: &str) -> Result<Self, String> {
        Ok(Self)
    }

    pub async fn predict(&self, _features: &[f64]) -> Result<TlobPrediction, String> {
        tokio::time::sleep(Duration::from_micros(5000)).await; // 5ms simulation
        Ok(TlobPrediction {
            confidence: 0.8,
            direction_probability: vec![0.6, 0.3, 0.1],
        })
    }
}

impl MambaSSM {
    pub async fn load_pretrained(_path: &str) -> Result<Self, String> {
        Ok(Self)
    }

    pub async fn predict_with_state(&self, _features: &[f64]) -> Result<MambaPrediction, String> {
        tokio::time::sleep(Duration::from_micros(3000)).await; // 3ms simulation
        Ok(MambaPrediction {
            price_target: 1.1050,
            volatility_forecast: 0.15,
        })
    }
}

impl DqnAgent {
    pub async fn load_pretrained(_path: &str) -> Result<Self, String> {
        Ok(Self)
    }

    pub async fn select_action(&self, _state: &[f64]) -> Result<RlAction, String> {
        tokio::time::sleep(Duration::from_micros(2000)).await; // 2ms simulation
        Ok(RlAction {
            position_size: 0.3,
        })
    }
}

impl PpoAgent {
    pub async fn load_pretrained(_path: &str) -> Result<Self, String> {
        Ok(Self)
    }

    pub async fn select_action(&self, _state: &[f64]) -> Result<RlAction, String> {
        tokio::time::sleep(Duration::from_micros(2000)).await; // 2ms simulation
        Ok(RlAction {
            position_size: 0.25,
        })
    }
}

impl ModelEnsemble {
    pub fn new(_weights: HashMap<String, f64>) -> Self {
        Self
    }

    pub async fn combine_predictions(
        &self,
        _tlob: &TlobPrediction,
        _mamba: &MambaPrediction,
        _dqn: &RlAction,
        _ppo: &RlAction,
    ) -> Result<EnsembleResult, String> {
        tokio::time::sleep(Duration::from_micros(1000)).await; // 1ms simulation
        
        let mut weights = HashMap::new();
        weights.insert("tlob".to_string(), 0.4);
        weights.insert("mamba".to_string(), 0.3);
        weights.insert("dqn".to_string(), 0.2);
        weights.insert("ppo".to_string(), 0.1);

        Ok(EnsembleResult {
            confidence: 0.75,
            weight_distribution: weights,
        })
    }
}

impl TradingSignalGenerator {
    pub fn new(_threshold: f64) -> Self {
        Self
    }

    pub async fn generate_signal_from_tlob(
        &self,
        _prediction: &TlobPrediction,
        _symbol: &str,
    ) -> Result<TradingSignal, String> {
        Ok(TradingSignal {
            action: "BUY".to_string(),
            confidence: 0.8,
            size: 0.3,
        })
    }

    pub async fn generate_traditional_signal(
        &self,
        _data: &MarketDataPoint,
        _symbol: &str,
    ) -> Result<TradingSignal, String> {
        Ok(TradingSignal {
            action: "HOLD".to_string(),
            confidence: 0.6,
            size: 0.0,
        })
    }
}

impl FeaturePipeline {
    pub fn new() -> Self {
        Self
    }

    pub async fn extract_tlob_features(&self, _data: &MarketDataPoint) -> Result<Vec<f64>, String> {
        Ok(vec![1.0, 2.0, 3.0, 4.0, 5.0]) // Mock features
    }

    pub async fn extract_mamba_features(&self, _data: &MarketDataPoint) -> Result<Vec<f64>, String> {
        Ok(vec![0.1, 0.2, 0.3, 0.4, 0.5]) // Mock features
    }

    pub async fn extract_rl_state(&self, _data: &MarketDataPoint) -> Result<Vec<f64>, String> {
        Ok(vec![0.5, 0.4, 0.3, 0.2, 0.1]) // Mock state
    }
}

// =============================================================================
// INTEGRATION TESTS
// =============================================================================

#[tokio::test]
async fn test_ml_trading_tlob_integration() -> TestResult<()> {
    let config = MlTradingIntegrationConfig::default();
    let suite = MlTradingIntegrationSuite::new(config).await?;
    
    suite.test_tlob_transformer_integration().await?;
    
    Ok(())
}

#[tokio::test]
async fn test_ml_trading_mamba_integration() -> TestResult<()> {
    let config = MlTradingIntegrationConfig::default();
    let suite = MlTradingIntegrationSuite::new(config).await?;
    
    suite.test_mamba_ssm_integration().await?;
    
    Ok(())
}

#[tokio::test]
async fn test_ml_trading_rl_agents() -> TestResult<()> {
    let config = MlTradingIntegrationConfig::default();
    let suite = MlTradingIntegrationSuite::new(config).await?;
    
    suite.test_rl_agents_integration().await?;
    
    Ok(())
}

#[tokio::test]
async fn test_ml_trading_ensemble() -> TestResult<()> {
    let config = MlTradingIntegrationConfig::default();
    let suite = MlTradingIntegrationSuite::new(config).await?;
    
    suite.test_model_ensemble_integration().await?;
    
    Ok(())
}

#[tokio::test]
async fn test_ml_trading_fallback() -> TestResult<()> {
    let config = MlTradingIntegrationConfig::default();
    let suite = MlTradingIntegrationSuite::new(config).await?;
    
    suite.test_fallback_mechanism().await?;
    
    Ok(())
}

#[tokio::test]
async fn test_ml_trading_hft_performance() -> TestResult<()> {
    let config = MlTradingIntegrationConfig::default();
    let suite = MlTradingIntegrationSuite::new(config).await?;
    
    suite.test_hft_performance_requirements().await?;
    
    Ok(())
}

/// Comprehensive ML-Trading integration test runner
#[tokio::test]
async fn run_comprehensive_ml_trading_integration_tests() -> TestResult<()> {
    println!("=== ML MODELS ↔ TRADING INTEGRATION TEST SUITE ===");
    
    let config = MlTradingIntegrationConfig::default();
    let suite = MlTradingIntegrationSuite::new(config).await?;
    
    let test_timeout = Duration::from_secs(180); // 3 minutes per test
    
    // Run all ML integration tests with timeout protection
    timeout(test_timeout, suite.test_tlob_transformer_integration()).await??;
    timeout(test_timeout, suite.test_mamba_ssm_integration()).await??;
    timeout(test_timeout, suite.test_rl_agents_integration()).await??;
    timeout(test_timeout, suite.test_model_ensemble_integration()).await??;
    timeout(test_timeout, suite.test_fallback_mechanism()).await??;
    timeout(test_timeout, suite.test_hft_performance_requirements()).await??;
    
    // Display final performance statistics
    let stats = suite.get_performance_stats().await;
    
    println!("=== ML ↔ TRADING INTEGRATION TEST RESULTS ===");
    println!("✓ TLOB transformer predictions → trading decisions");
    println!("✓ MAMBA-2 SSM real-time inference integration");
    println!("✓ DQN/PPO RL agent position sizing");
    println!("✓ Model ensemble voting and confidence scoring");
    println!("✓ Fallback to traditional indicators on ML failure");
    println!("✓ HFT performance requirements validation");
    println!("");
    println!("Performance Summary:");
    println!("  TLOB Average Latency: {}μs ({})", stats.avg_tlob_latency_us, stats.total_tlob_inferences);
    println!("  MAMBA Average Latency: {}μs ({})", stats.avg_mamba_latency_us, stats.total_mamba_inferences);
    println!("  DQN Average Latency: {}μs ({})", stats.avg_dqn_latency_us, stats.total_dqn_inferences);
    println!("  PPO Average Latency: {}μs ({})", stats.avg_ppo_latency_us, stats.total_ppo_inferences);
    println!("  Ensemble Average Latency: {}μs ({})", stats.avg_ensemble_latency_us, stats.total_ensemble_inferences);
    println!("");
    println!("✓ ALL ML ↔ TRADING INTEGRATION TESTS PASSED");
    
    Ok(())
}