foxhunt/tests/e2e/tests/comprehensive_trading_workflows.rs

//! Comprehensive Trading Workflow E2E Tests for Foxhunt HFT System
//!
//! This module contains comprehensive end-to-end test scenarios that validate
//! the complete trading system from data ingestion to order execution.
//!
//! ## Test Categories:
//! 1. **ML Inference Pipeline**: ML model predictions and ensemble
//! 2. **Data Flow Testing**: Feature extraction and ML integration
//! 3. **Performance Validation**: System latency and throughput
//!
//! ## Implementation Notes:
//! - Uses E2ETestFramework for service orchestration
//! - Tests simplified to match actual service APIs
//! - Focus on core workflows rather than edge cases
//! - Realistic expectations for service availability

use anyhow::{Context, Result};
use foxhunt_e2e::*;
use std::sync::Arc;
use std::time::Duration;
use tracing::{info, warn};

/// Test suite for comprehensive trading workflows
pub struct ComprehensiveTradingWorkflows {
    framework: Arc<E2ETestFramework>,
}

impl ComprehensiveTradingWorkflows {
    pub fn new(framework: Arc<E2ETestFramework>) -> Self {
        Self { framework }
    }

    /// Test ML Inference Pipeline
    ///
    /// Tests ML model predictions with ensemble approach
    pub async fn test_ml_inference_pipeline(&self) -> Result<WorkflowTestResult> {
        info!("🧠 Starting ML Inference Pipeline Test");

        let start_time = std::time::Instant::now();
        let workflow_name = "ml_inference_pipeline".to_string();
        let mut steps_completed = 0;
        let _total_steps = 5;

        // Access ML pipeline (read-only access to framework component)
        let _ml_pipeline = &self.framework.ml_pipeline;

        // Test different ML models
        let test_features: Vec<f64> = (0..100)
            .map(|_| rand::random::<f64>() * 2.0 - 1.0)
            .collect();

        // Test ensemble prediction (need to work around immutability)
        let ensemble_result = {
            // Clone ml_pipeline into a new mutable instance for testing
            let mut ml_test = ml_pipeline::MLPipelineTestHarness::new().await?;
            ml_test
                .test_ensemble_prediction(test_features.clone())
                .await
                .context("Ensemble prediction failed")?
        };

        info!(
            "✓ Ensemble prediction: {:?} with {:.2}% confidence",
            ensemble_result.prediction,
            ensemble_result.confidence * 100.0
        );
        steps_completed += 1;

        // Test individual model predictions
        let feature_vector = ml_pipeline::FeatureVector {
            features: test_features.clone(),
            feature_names: (0..100).map(|i| format!("feature_{}", i)).collect(),
            timestamp: chrono::Utc::now(),
            symbol: "TEST".to_string(),
        };

        // Create separate ML pipeline instance for mutation
        let mut ml_test = ml_pipeline::MLPipelineTestHarness::new().await?;

        // MAMBA test
        if ml_test
            .predict_with_mamba(&[feature_vector.clone()])
            .await
            .is_ok()
        {
            info!("✓ MAMBA prediction completed");
            steps_completed += 1;
        }

        // DQN test
        if ml_test
            .predict_with_dqn(&[feature_vector.clone()])
            .await
            .is_ok()
        {
            info!("✓ DQN prediction completed");
            steps_completed += 1;
        }

        // TFT test
        if ml_test
            .predict_with_tft(&[feature_vector.clone()])
            .await
            .is_ok()
        {
            info!("✓ TFT prediction completed");
            steps_completed += 1;
        }

        // TLOB test
        if ml_test.predict_with_tlob(&[feature_vector]).await.is_ok() {
            info!("✓ TLOB prediction completed");
            steps_completed += 1;
        }

        let duration = start_time.elapsed();
        info!("✅ ML Inference Pipeline completed in {:?}", duration);

        let mut metrics = std::collections::HashMap::new();
        metrics.insert(
            "ensemble_confidence".to_string(),
            ensemble_result.confidence,
        );
        metrics.insert(
            "ensemble_signal_strength".to_string(),
            ensemble_result.signal_strength,
        );

        let mut result = WorkflowTestResult::success(workflow_name, duration, steps_completed);
        result.metrics = metrics;

        Ok(result)
    }

    /// Test Data Flow Integration
    ///
    /// Tests data pipeline from generation to ML inference
    pub async fn test_data_flow_integration(&self) -> Result<WorkflowTestResult> {
        info!("📈 Starting Data Flow Integration Test");

        let start_time = std::time::Instant::now();
        let workflow_name = "data_flow_integration".to_string();
        let mut steps_completed = 0;
        let _total_steps = 4;

        // Generate test market data
        let market_data = test_utils::generate_market_data("AAPL", 1000);
        info!("✓ Generated {} market ticks", market_data.len());
        steps_completed += 1;

        // Extract features from market data
        let mut ml_test = ml_pipeline::MLPipelineTestHarness::new().await?;
        let features = ml_test
            .extract_features(&market_data)
            .await
            .context("Feature extraction failed")?;
        info!("✓ Extracted {} feature vectors", features.len());
        steps_completed += 1;

        // Run ML prediction on extracted features
        if !features.is_empty() {
            let prediction = ml_test
                .predict_ensemble(&features)
                .await
                .context("ML prediction failed")?;
            info!(
                "✓ ML prediction: {:?} with {:.2}% confidence",
                prediction.prediction,
                prediction.confidence * 100.0
            );
            steps_completed += 1;
        }

        // Verify end-to-end pipeline latency
        let duration = start_time.elapsed();
        if duration < Duration::from_millis(500) {
            info!(
                "✓ Pipeline completed in {:?} (within latency target)",
                duration
            );
            steps_completed += 1;
        } else {
            warn!("⚠ Pipeline took {:?} (may exceed latency target)", duration);
        }

        let mut metrics = std::collections::HashMap::new();
        metrics.insert("market_data_events".to_string(), market_data.len() as f64);
        metrics.insert("feature_vectors".to_string(), features.len() as f64);
        metrics.insert("pipeline_ms".to_string(), duration.as_millis() as f64);

        let mut result = WorkflowTestResult::success(workflow_name, duration, steps_completed);
        result.metrics = metrics;

        info!("✅ Data Flow Integration completed in {:?}", duration);

        Ok(result)
    }

    /// Test Performance Validation
    ///
    /// Tests that the system meets performance requirements
    pub async fn test_performance_validation(&self) -> Result<WorkflowTestResult> {
        info!("⚡ Starting Performance Validation Test");

        let start_time = std::time::Instant::now();
        let workflow_name = "performance_validation".to_string();
        let mut steps_completed = 0;
        let _total_steps = 3;

        // Test ML inference latency
        let mut ml_test = ml_pipeline::MLPipelineTestHarness::new().await?;
        let test_features: Vec<f64> = (0..50).map(|_| rand::random::<f64>()).collect();

        let inference_start = std::time::Instant::now();
        let _prediction = ml_test
            .test_ensemble_prediction(test_features)
            .await
            .context("ML prediction failed")?;
        let inference_latency = inference_start.elapsed();

        info!("✓ ML inference latency: {:?}", inference_latency);
        steps_completed += 1;

        // Verify latency is within acceptable range (< 100ms for ensemble)
        if inference_latency < Duration::from_millis(100) {
            info!("✓ ML inference meets latency target");
            steps_completed += 1;
        } else {
            warn!(
                "⚠ ML inference latency exceeds target: {:?}",
                inference_latency
            );
        }

        // Test feature extraction performance
        let market_data = test_utils::generate_market_data("AAPL", 100);
        let extraction_start = std::time::Instant::now();
        let _features = ml_test.extract_features(&market_data).await?;
        let extraction_latency = extraction_start.elapsed();

        info!("✓ Feature extraction latency: {:?}", extraction_latency);
        steps_completed += 1;

        let duration = start_time.elapsed();
        let mut metrics = std::collections::HashMap::new();
        metrics.insert(
            "ml_inference_ms".to_string(),
            inference_latency.as_millis() as f64,
        );
        metrics.insert(
            "feature_extraction_ms".to_string(),
            extraction_latency.as_millis() as f64,
        );

        let mut result = WorkflowTestResult::success(workflow_name, duration, steps_completed);
        result.metrics = metrics;

        info!("✅ Performance Validation completed in {:?}", duration);

        Ok(result)
    }

    /// Test ML Model Failover
    ///
    /// Tests that ensemble predictions work when individual models fail
    pub async fn test_ml_model_failover(&self) -> Result<WorkflowTestResult> {
        info!("🔄 Starting ML Model Failover Test");

        let start_time = std::time::Instant::now();
        let workflow_name = "ml_model_failover".to_string();
        let mut steps_completed = 0;
        let _total_steps = 4;

        // Create ML pipeline instance
        let mut ml_test = ml_pipeline::MLPipelineTestHarness::new().await?;

        // Test baseline ensemble prediction
        let test_features: Vec<f64> = (0..50).map(|_| rand::random::<f64>()).collect();
        let baseline = ml_test
            .test_ensemble_prediction(test_features.clone())
            .await?;
        info!(
            "✓ Baseline ensemble prediction: {:.2}% confidence",
            baseline.confidence * 100.0
        );
        steps_completed += 1;

        // Disable one model and verify ensemble still works
        ml_test.disable_model("mamba").await?;
        let failover1 = ml_test
            .test_ensemble_prediction(test_features.clone())
            .await?;
        info!(
            "✓ Ensemble works with MAMBA disabled: {:.2}% confidence",
            failover1.confidence * 100.0
        );
        steps_completed += 1;

        // Disable another model
        ml_test.disable_model("dqn").await?;
        let failover2 = ml_test
            .test_ensemble_prediction(test_features.clone())
            .await?;
        info!(
            "✓ Ensemble works with MAMBA+DQN disabled: {:.2}% confidence",
            failover2.confidence * 100.0
        );
        steps_completed += 1;

        // Re-enable models
        ml_test.enable_model("mamba").await?;
        ml_test.enable_model("dqn").await?;
        let restored = ml_test.test_ensemble_prediction(test_features).await?;
        info!(
            "✓ Ensemble restored: {:.2}% confidence",
            restored.confidence * 100.0
        );
        steps_completed += 1;

        let duration = start_time.elapsed();
        let mut metrics = std::collections::HashMap::new();
        metrics.insert("baseline_confidence".to_string(), baseline.confidence);
        metrics.insert("failover1_confidence".to_string(), failover1.confidence);
        metrics.insert("failover2_confidence".to_string(), failover2.confidence);
        metrics.insert("restored_confidence".to_string(), restored.confidence);

        let mut result = WorkflowTestResult::success(workflow_name, duration, steps_completed);
        result.metrics = metrics;

        info!("✅ ML Model Failover completed in {:?}", duration);

        Ok(result)
    }
}

// ============================================================================
// Integration Tests
// ============================================================================

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

    e2e_test!(test_ml_inference_pipeline, |framework: Arc<
        E2ETestFramework,
    >| async move {
        let workflows = ComprehensiveTradingWorkflows::new(framework);
        let result = workflows.test_ml_inference_pipeline().await?;
        assert!(
            result.success,
            "ML inference pipeline failed: {:?}",
            result.error_message
        );
        assert!(
            result.metrics.contains_key("ensemble_confidence"),
            "Missing ensemble confidence metric"
        );
        Ok(())
    });

    e2e_test!(test_data_flow_integration, |framework: Arc<
        E2ETestFramework,
    >| async move {
        let workflows = ComprehensiveTradingWorkflows::new(framework);
        let result = workflows.test_data_flow_integration().await?;
        assert!(
            result.success,
            "Data flow integration failed: {:?}",
            result.error_message
        );
        assert!(
            result.metrics.get("pipeline_ms").unwrap_or(&1000.0) < &500.0,
            "Pipeline latency too high"
        );
        Ok(())
    });

    e2e_test!(test_performance_validation, |framework: Arc<
        E2ETestFramework,
    >| async move {
        let workflows = ComprehensiveTradingWorkflows::new(framework);
        let result = workflows.test_performance_validation().await?;
        assert!(
            result.success,
            "Performance validation failed: {:?}",
            result.error_message
        );
        let ml_latency = result.metrics.get("ml_inference_ms").unwrap_or(&1000.0);
        assert!(
            ml_latency < &100.0,
            "ML inference too slow: {}ms",
            ml_latency
        );
        Ok(())
    });

    e2e_test!(test_ml_model_failover, |framework: Arc<
        E2ETestFramework,
    >| async move {
        let workflows = ComprehensiveTradingWorkflows::new(framework);
        let result = workflows.test_ml_model_failover().await?;
        assert!(
            result.success,
            "ML model failover failed: {:?}",
            result.error_message
        );
        assert!(
            result.metrics.contains_key("baseline_confidence"),
            "Missing baseline confidence metric"
        );
        Ok(())
    });
}