foxhunt/tests/integration/mod.rs

//! Integration tests across modules

use std::time::{Duration, Instant};

use crate::framework::{TestOrchestrator, IntegrationTestResult};

// Existing integration tests
pub mod broker_integration_tests;
pub mod broker_failover;
pub mod icmarkets_validation;
pub mod interactive_brokers_validation;
pub mod broker_risk_integration;
pub mod database_integration;
pub mod end_to_end_trading;
pub mod order_lifecycle;
pub mod module_integration_test;
pub mod network_failure_simulation;
pub mod run_integration_tests;
pub mod run_broker_validation;

// New comprehensive integration tests (Layer 1: Service Pairs)
pub mod tli_trading_integration;
pub mod ml_trading_integration;
pub mod trading_risk_integration;
pub mod dual_provider_test;

// Enhanced comprehensive integration test framework
pub mod trading_service_tests;
pub mod backtesting_service_tests;
pub mod ml_training_service_tests;
pub mod tli_client_tests;
pub mod service_tests;

// Re-export test suites for easy access
pub use trading_service_tests::TradingServiceTests;
pub use backtesting_service_tests::BacktestingServiceTests;
pub use ml_training_service_tests::MLTrainingServiceTests;
pub use tli_client_tests::TLIClientTests;
pub use service_tests::ComprehensiveServiceTests;

/// Master Integration Test Runner
///
/// Orchestrates execution of all integration test suites with proper
/// service lifecycle management, dependency handling, and result aggregation.
pub struct MasterIntegrationTestRunner {
    orchestrator: TestOrchestrator,
}

impl MasterIntegrationTestRunner {
    /// Initialize the master test runner
    pub async fn new() -> Result<Self, Box<dyn std::error::Error>> {
        let orchestrator = TestOrchestrator::new_with_defaults().await?;

        Ok(Self {
            orchestrator,
        })
    }

    /// Run all integration test suites in optimal order
    ///
    /// This method executes all integration tests with proper dependency management:
    /// 1. Framework validation tests
    /// 2. Individual service tests (parallel where possible)
    /// 3. TLI client tests (requires all services)
    /// 4. Comprehensive end-to-end tests
    pub async fn run_all_integration_tests(&self) -> Result<MasterTestResults, Box<dyn std::error::Error>> {
        println!("🚀 Starting Foxhunt HFT System - Master Integration Test Suite");
        println!("   Testing complete system with all services and components");

        let master_start = Instant::now();
        let mut all_results = Vec::new();
        let mut test_summary = TestSummary::new();

        // Phase 1: Framework Validation
        println!("\n📋 Phase 1: Framework Validation Tests");
        match self.run_framework_validation_tests().await {
            Ok(framework_results) => {
                test_summary.add_results(&framework_results);
                all_results.extend(framework_results);
                println!("✅ Framework validation completed");
            }
            Err(e) => {
                println!("❌ Framework validation failed: {}", e);
                let mut failed_result = IntegrationTestResult::new("Framework Validation");
                failed_result.add_failure(&format!("Framework validation failed: {}", e));
                failed_result.finalize();
                all_results.push(failed_result);
                test_summary.framework_failed = true;
            }
        }

        // Phase 2: Individual Service Tests (Parallel Execution)
        println!("\n🔧 Phase 2: Individual Service Integration Tests");
        if !test_summary.framework_failed {
            match self.run_service_tests_parallel().await {
                Ok(service_results) => {
                    test_summary.add_results(&service_results);
                    all_results.extend(service_results);
                    println!("✅ All service tests completed");
                }
                Err(e) => {
                    println!("❌ Service tests failed: {}", e);
                    let mut failed_result = IntegrationTestResult::new("Service Tests");
                    failed_result.add_failure(&format!("Service tests failed: {}", e));
                    failed_result.finalize();
                    all_results.push(failed_result);
                    test_summary.services_failed = true;
                }
            }
        } else {
            println!("⏭️ Skipping service tests due to framework validation failure");
        }

        // Phase 3: TLI Client Tests (Requires All Services)
        println!("\n💻 Phase 3: TLI Client Integration Tests");
        if !test_summary.framework_failed && !test_summary.services_failed {
            match self.run_tli_client_tests().await {
                Ok(tli_results) => {
                    test_summary.add_results(&tli_results);
                    all_results.extend(tli_results);
                    println!("✅ TLI client tests completed");
                }
                Err(e) => {
                    println!("❌ TLI client tests failed: {}", e);
                    let mut failed_result = IntegrationTestResult::new("TLI Client Tests");
                    failed_result.add_failure(&format!("TLI client tests failed: {}", e));
                    failed_result.finalize();
                    all_results.push(failed_result);
                    test_summary.tli_failed = true;
                }
            }
        } else {
            println!("⏭️ Skipping TLI client tests due to prerequisite failures");
        }

        // Phase 4: Comprehensive End-to-End Tests
        println!("\n🔄 Phase 4: Comprehensive End-to-End Tests");
        if !test_summary.has_critical_failures() {
            match self.run_comprehensive_e2e_tests().await {
                Ok(e2e_results) => {
                    test_summary.add_results(&e2e_results);
                    all_results.extend(e2e_results);
                    println!("✅ End-to-end tests completed");
                }
                Err(e) => {
                    println!("❌ End-to-end tests failed: {}", e);
                    let mut failed_result = IntegrationTestResult::new("End-to-End Tests");
                    failed_result.add_failure(&format!("End-to-end tests failed: {}", e));
                    failed_result.finalize();
                    all_results.push(failed_result);
                    test_summary.e2e_failed = true;
                }
            }
        } else {
            println!("⏭️ Skipping end-to-end tests due to critical failures in previous phases");
        }

        let master_duration = master_start.elapsed();

        // Generate comprehensive report
        let master_results = MasterTestResults {
            total_duration: master_duration,
            all_results,
            summary: test_summary,
            system_validated: !test_summary.has_critical_failures(),
        };

        self.print_master_summary(&master_results);

        Ok(master_results)
    }

    /// Run framework validation tests
    async fn run_framework_validation_tests(&self) -> Result<Vec<IntegrationTestResult>, Box<dyn std::error::Error>> {
        let comprehensive_tests = ComprehensiveServiceTests::new().await?;

        // Run only the framework validation portion
        let framework_result = comprehensive_tests.test_framework_initialization().await?;

        Ok(vec![framework_result])
    }

    /// Run individual service tests in parallel
    async fn run_service_tests_parallel(&self) -> Result<Vec<IntegrationTestResult>, Box<dyn std::error::Error>> {
        println!("   Running Trading, Backtesting, and ML Training service tests in parallel...");

        // Create test suites
        let trading_tests = TradingServiceTests::new().await?;
        let backtesting_tests = BacktestingServiceTests::new().await?;
        let ml_training_tests = MLTrainingServiceTests::new().await?;

        // Run service tests in parallel
        let (trading_results, backtesting_results, ml_training_results) = tokio::join!(
            trading_tests.run_all_tests(),
            backtesting_tests.run_all_tests(),
            ml_training_tests.run_all_tests()
        );

        let mut all_service_results = Vec::new();

        // Collect Trading Service results
        match trading_results {
            Ok(results) => {
                println!("   ✅ Trading Service: {}/{} test suites passed",
                    results.iter().filter(|r| r.passed).count(),
                    results.len());
                all_service_results.extend(results);
            }
            Err(e) => {
                println!("   ❌ Trading Service tests failed: {}", e);
                let mut failed_result = IntegrationTestResult::new("Trading Service Tests");
                failed_result.add_failure(&format!("Trading service tests failed: {}", e));
                failed_result.finalize();
                all_service_results.push(failed_result);
            }
        }

        // Collect Backtesting Service results
        match backtesting_results {
            Ok(results) => {
                println!("   ✅ Backtesting Service: {}/{} test suites passed",
                    results.iter().filter(|r| r.passed).count(),
                    results.len());
                all_service_results.extend(results);
            }
            Err(e) => {
                println!("   ❌ Backtesting Service tests failed: {}", e);
                let mut failed_result = IntegrationTestResult::new("Backtesting Service Tests");
                failed_result.add_failure(&format!("Backtesting service tests failed: {}", e));
                failed_result.finalize();
                all_service_results.push(failed_result);
            }
        }

        // Collect ML Training Service results
        match ml_training_results {
            Ok(results) => {
                println!("   ✅ ML Training Service: {}/{} test suites passed",
                    results.iter().filter(|r| r.passed).count(),
                    results.len());
                all_service_results.extend(results);
            }
            Err(e) => {
                println!("   ❌ ML Training Service tests failed: {}", e);
                let mut failed_result = IntegrationTestResult::new("ML Training Service Tests");
                failed_result.add_failure(&format!("ML training service tests failed: {}", e));
                failed_result.finalize();
                all_service_results.push(failed_result);
            }
        }

        Ok(all_service_results)
    }

    /// Run TLI client tests
    async fn run_tli_client_tests(&self) -> Result<Vec<IntegrationTestResult>, Box<dyn std::error::Error>> {
        let tli_tests = TLIClientTests::new().await?;
        let tli_results = tli_tests.run_all_tests().await?;

        println!("   ✅ TLI Client: {}/{} test suites passed",
            tli_results.iter().filter(|r| r.passed).count(),
            tli_results.len());

        Ok(tli_results)
    }

    /// Run comprehensive end-to-end tests
    async fn run_comprehensive_e2e_tests(&self) -> Result<Vec<IntegrationTestResult>, Box<dyn std::error::Error>> {
        let comprehensive_tests = ComprehensiveServiceTests::new().await?;
        let e2e_results = comprehensive_tests.run_all_tests().await?;

        println!("   ✅ End-to-End Tests: {}/{} test suites passed",
            e2e_results.iter().filter(|r| r.passed).count(),
            e2e_results.len());

        Ok(e2e_results)
    }

    /// Print comprehensive test summary
    fn print_master_summary(&self, results: &MasterTestResults) {
        println!("\n" + "=".repeat(80).as_str());
        println!("🎯 FOXHUNT HFT SYSTEM - MASTER INTEGRATION TEST RESULTS");
        println!("=".repeat(80));

        // Overall status
        if results.system_validated {
            println!("🎉 SYSTEM STATUS: ✅ VALIDATED - All critical tests passed");
        } else {
            println!("⚠️ SYSTEM STATUS: ❌ VALIDATION FAILED - Critical issues detected");
        }

        println!("⏱️ Total Test Duration: {:.1} minutes", results.total_duration.as_secs_f64() / 60.0);

        // Test suite breakdown
        println!("\n📊 Test Suite Breakdown:");
        println!("   Total Test Suites: {}", results.all_results.len());
        println!("   Passed: {} ✅", results.summary.total_passed);
        println!("   Failed: {} ❌", results.summary.total_failed);
        println!("   Success Rate: {:.1}%",
            if results.all_results.is_empty() { 0.0 } else {
                (results.summary.total_passed as f64 / results.all_results.len() as f64) * 100.0
            }
        );

        // Phase-by-phase results
        println!("\n🔍 Phase-by-Phase Results:");

        if !results.summary.framework_failed {
            println!("   📋 Framework Validation: ✅ PASSED");
        } else {
            println!("   📋 Framework Validation: ❌ FAILED");
        }

        if !results.summary.services_failed {
            println!("   🔧 Service Integration: ✅ PASSED");
        } else {
            println!("   🔧 Service Integration: ❌ FAILED");
        }

        if !results.summary.tli_failed {
            println!("   💻 TLI Client: ✅ PASSED");
        } else {
            println!("   💻 TLI Client: ❌ FAILED");
        }

        if !results.summary.e2e_failed {
            println!("   🔄 End-to-End: ✅ PASSED");
        } else {
            println!("   🔄 End-to-End: ❌ FAILED");
        }

        // Performance summary
        if let Some(performance_summary) = &results.summary.performance_summary {
            println!("\n⚡ Performance Summary:");
            println!("   Average Latency: {:.1}μs", performance_summary.avg_latency_us);
            println!("   P99 Latency: {:.1}μs", performance_summary.p99_latency_us);
            println!("   Throughput: {:.0} ops/sec", performance_summary.avg_throughput_ops_sec);

            if performance_summary.meets_hft_requirements {
                println!("   HFT Requirements: ✅ MET");
            } else {
                println!("   HFT Requirements: ❌ NOT MET");
            }
        }

        // Failed tests detail
        if results.summary.total_failed > 0 {
            println!("\n❌ Failed Test Details:");
            for (i, result) in results.all_results.iter().enumerate() {
                if !result.passed {
                    println!("   {}: {} ({} failures)",
                        i + 1, result.test_name, result.failures.len());
                    for failure in &result.failures {
                        println!("      - {}", failure);
                    }
                }
            }
        }

        // Next steps
        println!("\n🎯 Next Steps:");
        if results.system_validated {
            println!("   ✅ System ready for production deployment");
            println!("   ✅ All HFT performance requirements validated");
            println!("   ✅ All service integrations working correctly");
        } else {
            println!("   ❌ Address critical test failures before deployment");
            println!("   ❌ Review failed test details above");
            println!("   ❌ Re-run integration tests after fixes");
        }

        println!("\n" + "=".repeat(80).as_str());
    }

    /// Run a subset of tests for quick validation
    pub async fn run_smoke_tests(&self) -> Result<MasterTestResults, Box<dyn std::error::Error>> {
        println!("💨 Running Smoke Tests - Quick System Validation");

        let smoke_start = Instant::now();
        let mut smoke_results = Vec::new();
        let mut test_summary = TestSummary::new();

        // Smoke test: Basic service connectivity
        let comprehensive_tests = ComprehensiveServiceTests::new().await?;

        match comprehensive_tests.test_service_communication().await {
            Ok(result) => {
                test_summary.add_result(&result);
                smoke_results.push(result);
            }
            Err(e) => {
                let mut failed_result = IntegrationTestResult::new("Smoke Test - Service Communication");
                failed_result.add_failure(&format!("Smoke test failed: {}", e));
                failed_result.finalize();
                smoke_results.push(failed_result);
            }
        }

        // Smoke test: Basic TLI connectivity
        let tli_tests = TLIClientTests::new().await?;
        match tli_tests.test_service_connection_management().await {
            Ok(result) => {
                test_summary.add_result(&result);
                smoke_results.push(result);
            }
            Err(e) => {
                let mut failed_result = IntegrationTestResult::new("Smoke Test - TLI Connection");
                failed_result.add_failure(&format!("TLI smoke test failed: {}", e));
                failed_result.finalize();
                smoke_results.push(failed_result);
            }
        }

        let smoke_duration = smoke_start.elapsed();

        let smoke_test_results = MasterTestResults {
            total_duration: smoke_duration,
            all_results: smoke_results,
            summary: test_summary,
            system_validated: test_summary.total_failed == 0,
        };

        println!("💨 Smoke Tests Completed in {:.1}s: {} passed, {} failed",
            smoke_duration.as_secs_f64(),
            smoke_test_results.summary.total_passed,
            smoke_test_results.summary.total_failed);

        Ok(smoke_test_results)
    }
}

/// Aggregated results from all integration tests
#[derive(Debug)]
pub struct MasterTestResults {
    pub total_duration: Duration,
    pub all_results: Vec<IntegrationTestResult>,
    pub summary: TestSummary,
    pub system_validated: bool,
}

/// Test execution summary
#[derive(Debug)]
pub struct TestSummary {
    pub total_passed: usize,
    pub total_failed: usize,
    pub framework_failed: bool,
    pub services_failed: bool,
    pub tli_failed: bool,
    pub e2e_failed: bool,
    pub performance_summary: Option<PerformanceSummary>,
}

impl TestSummary {
    pub fn new() -> Self {
        Self {
            total_passed: 0,
            total_failed: 0,
            framework_failed: false,
            services_failed: false,
            tli_failed: false,
            e2e_failed: false,
            performance_summary: None,
        }
    }

    pub fn add_result(&mut self, result: &IntegrationTestResult) {
        if result.passed {
            self.total_passed += 1;
        } else {
            self.total_failed += 1;
        }
    }

    pub fn add_results(&mut self, results: &[IntegrationTestResult]) {
        for result in results {
            self.add_result(result);
        }
    }

    pub fn has_critical_failures(&self) -> bool {
        self.framework_failed || self.services_failed
    }
}

/// Performance metrics summary
#[derive(Debug)]
pub struct PerformanceSummary {
    pub avg_latency_us: f64,
    pub p99_latency_us: f64,
    pub avg_throughput_ops_sec: f64,
    pub meets_hft_requirements: bool,
}

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

    #[tokio::test]
    async fn test_master_integration_runner_smoke_tests() {
        let runner = MasterIntegrationTestRunner::new().await
            .expect("Failed to create master test runner");

        let smoke_results = runner.run_smoke_tests().await
            .expect("Failed to run smoke tests");

        // Smoke tests should complete quickly
        assert!(smoke_results.total_duration.as_secs() <= 30,
            "Smoke tests took too long: {}s", smoke_results.total_duration.as_secs());

        // At least some tests should have run
        assert!(!smoke_results.all_results.is_empty(), "No smoke tests executed");
    }

    #[tokio::test]
    #[ignore] // This is a long-running test
    async fn test_master_integration_runner_full_suite() {
        let runner = MasterIntegrationTestRunner::new().await
            .expect("Failed to create master test runner");

        let full_results = runner.run_all_integration_tests().await
            .expect("Failed to run full integration test suite");

        // Full test suite should complete within reasonable time
        assert!(full_results.total_duration.as_secs() <= 1800, // 30 minutes
            "Full test suite took too long: {} minutes", full_results.total_duration.as_secs() / 60);

        // Should have comprehensive coverage
        assert!(full_results.all_results.len() >= 10,
            "Not enough test suites executed: {}", full_results.all_results.len());

        // For a properly functioning system, most tests should pass
        let success_rate = full_results.summary.total_passed as f64 /
                          (full_results.summary.total_passed + full_results.summary.total_failed) as f64;

        assert!(success_rate >= 0.8,
            "Success rate too low: {:.1}% ({} passed, {} failed)",
            success_rate * 100.0,
            full_results.summary.total_passed,
            full_results.summary.total_failed);
    }
}