//! Enhanced Integration Testing Framework for Foxhunt HFT System
//! 
//! This module provides a unified testing framework that orchestrates all three services
//! (Trading, Backtesting, ML Training) along with TLI client testing, database hot-reload
//! validation, and kill switch system verification.
//!
//! ## Key Features:
//! - Unified service lifecycle management
//! - Centralized mock implementations
//! - Performance metrics collection
//! - Cross-service integration validation
//! - Kill switch emergency testing
//! - Database hot-reload verification
//! 
//! ## Usage:
//! ```rust
//! use tests::framework::TestOrchestrator;
//! 
//! let orchestrator = TestOrchestrator::new().await?;
//! orchestrator.run_integration_tests().await?;
//! ```

pub mod orchestrator;
pub mod mocks;
pub mod metrics;
pub mod services;

pub use orchestrator::*;
pub use mocks::*;
pub use metrics::*;
pub use services::*;

use std::collections::HashMap;
use std::sync::Arc;
use std::time::{Duration, Instant};
use tokio::sync::{RwLock, broadcast, mpsc};
use tokio::time::timeout;
use tracing::{info, warn, error, debug};
use uuid::Uuid;

use trading_engine::prelude::*;
use risk::prelude::*;

/// Test framework configuration
#[derive(Debug, Clone)]
pub struct TestFrameworkConfig {
    /// Maximum test execution timeout
    pub max_test_timeout: Duration,
    /// Service startup timeout  
    pub service_startup_timeout: Duration,
    /// Service health check timeout
    pub health_check_timeout: Duration,
    /// Database connection timeout
    pub database_timeout: Duration,
    /// Kill switch activation timeout
    pub kill_switch_timeout: Duration,
    /// Performance threshold validation
    pub performance_thresholds: PerformanceThresholds,
    /// Test environment configuration
    pub test_environment: TestEnvironment,
}

impl Default for TestFrameworkConfig {
    fn default() -> Self {
        Self {
            max_test_timeout: Duration::from_secs(300),
            service_startup_timeout: Duration::from_secs(30),
            health_check_timeout: Duration::from_secs(10),
            database_timeout: Duration::from_secs(15),
            kill_switch_timeout: Duration::from_secs(5),
            performance_thresholds: PerformanceThresholds::hft_defaults(),
            test_environment: TestEnvironment::Development,
        }
    }
}

/// Performance thresholds for validation
#[derive(Debug, Clone)]
pub struct PerformanceThresholds {
    /// Maximum end-to-end latency (microseconds)
    pub max_e2e_latency_us: u64,
    /// Maximum order processing latency (microseconds) 
    pub max_order_latency_us: u64,
    /// Maximum risk validation latency (microseconds)
    pub max_risk_latency_us: u64,
    /// Maximum ML inference latency (milliseconds)
    pub max_ml_latency_ms: u64,
    /// Maximum database hot-reload latency (milliseconds)
    pub max_config_reload_ms: u64,
    /// Minimum throughput (operations per second)
    pub min_throughput_ops_sec: u64,
}

impl PerformanceThresholds {
    pub fn hft_defaults() -> Self {
        Self {
            max_e2e_latency_us: 50,        // 50μs end-to-end
            max_order_latency_us: 20,      // 20μs order processing
            max_risk_latency_us: 10,       // 10μs risk validation
            max_ml_latency_ms: 50,         // 50ms ML inference
            max_config_reload_ms: 100,     // 100ms config reload
            min_throughput_ops_sec: 10000, // 10k ops/sec minimum
        }
    }
}

/// Test environment types
#[derive(Debug, Clone, PartialEq)]
pub enum TestEnvironment {
    Development,
    CI,
    Staging,
    Performance,
}

/// Comprehensive test result
#[derive(Debug, Clone)]
pub struct IntegrationTestResult {
    pub test_name: String,
    pub success: bool,
    pub duration: Duration,
    pub metrics: TestMetrics,
    pub errors: Vec<String>,
    pub warnings: Vec<String>,
}

/// Test execution metrics
#[derive(Debug, Clone, Default)]
pub struct TestMetrics {
    /// Service startup times
    pub service_startup_times: HashMap<String, Duration>,
    /// gRPC communication latencies
    pub grpc_latencies: HashMap<String, Vec<Duration>>,
    /// Database operation latencies
    pub database_latencies: Vec<Duration>,
    /// Kill switch activation times
    pub kill_switch_times: Vec<Duration>,
    /// Memory usage measurements
    pub memory_usage: Vec<u64>,
    /// Throughput measurements (ops/sec)
    pub throughput_measurements: Vec<u64>,
}

/// Test validation errors
#[derive(Debug, thiserror::Error)]
pub enum TestFrameworkError {
    #[error("Service startup timeout: {service}")]
    ServiceStartupTimeout { service: String },
    
    #[error("Health check failed for service: {service}")]
    HealthCheckFailed { service: String },
    
    #[error("Performance threshold exceeded: {metric} = {value:?}, limit = {limit:?}")]
    PerformanceThresholdExceeded {
        metric: String,
        value: Duration,
        limit: Duration,
    },
    
    #[error("Kill switch activation failed: {reason}")]
    KillSwitchFailed { reason: String },
    
    #[error("Database hot-reload failed: {reason}")]
    DatabaseHotReloadFailed { reason: String },
    
    #[error("Cross-service integration failed: {reason}")]
    CrossServiceIntegrationFailed { reason: String },
    
    #[error("Test timeout exceeded: {test_name}")]
    TestTimeout { test_name: String },
}

pub type TestResult<T> = std::result::Result<T, TestFrameworkError>;