//! Foxhunt Critical Path Tests Library
//!
//! This library provides comprehensive integration tests for the Foxhunt HFT trading system.
//! It includes tests for performance, safety, reliability, and functional correctness across
//! all system components.

#![warn(missing_docs)]
#![warn(missing_debug_implementations)]
#![warn(rust_2018_idioms)]

// Test dependencies and external crates
pub use data;
pub use core::prelude::*;
pub use core::types::prelude::*;
pub use ml;
pub use risk;
pub use tli;

// Standard library imports
pub use std::collections::HashMap;
pub use std::sync::{Arc, Mutex};
pub use std::time::{Duration, Instant};

// Async runtime imports
pub use tokio;
pub use tokio::sync::{broadcast, RwLock};
pub use tokio_test;

// Testing utilities
pub use criterion::{self, black_box, Criterion};
pub use proptest::prelude::*;
pub use quickcheck::{self, QuickCheck, TestResult};

// Serialization and time
pub use chrono::{DateTime, TimeZone, Utc};
pub use serde::{Deserialize, Serialize};

// Mathematical operations
pub use num::traits::{One, Zero};

// Concurrency
pub use arc_swap::ArcSwap;
pub use crossbeam;

// Async utilities
pub use async_trait::async_trait;
pub use futures::prelude::*;

// Logging and tracing
pub use tracing::{debug, error, info, trace, warn};
pub use tracing_subscriber;

// Chaos engineering module
pub mod chaos;

// Test modules - external files (only enable working ones for now)
pub mod common;
// pub mod framework;      // Temporarily disabled
// pub mod helpers;        // Temporarily disabled
// pub mod unit;           // Temporarily disabled - has dependency issues
// pub mod integration;    // Temporarily disabled - missing broker modules
// pub mod performance;    // Temporarily disabled - missing dependencies
// pub mod gpu;            // Temporarily disabled - missing candle_core
pub mod utils;
// pub mod fixtures;       // Temporarily disabled - missing error_handling

// Performance utilities module
pub mod performance_utils {
    //! Performance testing utilities and benchmarks

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

    /// HFT performance requirements
    pub const MAX_LATENCY_NANOS: u64 = 50_000; // 50μs
    pub const MIN_THROUGHPUT_OPS_PER_SEC: u64 = 10_000; // 10k ops/sec

    /// Performance measurement utilities
    pub fn measure_operation<F, R>(operation: F) -> (R, Duration)
    where
        F: FnOnce() -> R,
    {
        let start = Instant::now();
        let result = operation();
        let duration = start.elapsed();
        (result, duration)
    }

    /// Async performance measurement
    pub async fn measure_async_operation<F, Fut, R>(operation: F) -> (R, Duration)
    where
        F: FnOnce() -> Fut,
        Fut: Future<Output = R>,
    {
        let start = Instant::now();
        let result = operation().await;
        let duration = start.elapsed();
        (result, duration)
    }

    /// Validate HFT latency requirements
    pub fn assert_hft_latency(duration: Duration, max_latency_us: u64) {
        let micros = duration.as_micros() as u64;
        assert!(
            micros <= max_latency_us,
            "Latency {}μs exceeds HFT requirement of {}μs",
            micros,
            max_latency_us
        );
    }

    /// Validate throughput requirements
    pub fn assert_hft_throughput(ops_per_sec: u64, operation: &str) {
        assert!(
            ops_per_sec >= MIN_THROUGHPUT_OPS_PER_SEC,
            "{} throughput {} ops/sec below HFT requirement of {} ops/sec",
            operation,
            ops_per_sec,
            MIN_THROUGHPUT_OPS_PER_SEC
        );
    }
}

// Safety test modules
pub mod safety {
    //! Safety testing utilities for error-free operations

    use super::*;

    /// Safe test result type
    pub type SafeTestResult<T> = Result<T, SafeTestError>;

    /// Safe test error types
    #[derive(Debug, Clone)]
    pub enum SafeTestError {
        /// Assertion failed with details
        AssertionFailed {
            /// Field that failed
            field: String,
            /// Expected value
            expected: String,
            /// Actual value
            actual: String,
        },
        /// Thread join operation failed
        ThreadJoinFailed {
            /// Type of thread that failed
            thread_type: String,
        },
        /// Operation timed out
        Timeout {
            /// Operation that timed out
            operation: String,
            /// Timeout duration in milliseconds
            timeout_ms: u64,
        },
        /// Calculation failed
        CalculationFailed {
            /// Operation that failed
            operation: String,
            /// Error details
            details: String,
        },
    }

    impl std::fmt::Display for SafeTestError {
        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
            match self {
                SafeTestError::AssertionFailed {
                    field,
                    expected,
                    actual,
                } => {
                    write!(
                        f,
                        "Assertion failed for {}: expected {}, got {}",
                        field, expected, actual
                    )
                }
                SafeTestError::ThreadJoinFailed { thread_type } => {
                    write!(f, "Thread join failed for: {}", thread_type)
                }
                SafeTestError::Timeout {
                    operation,
                    timeout_ms,
                } => {
                    write!(
                        f,
                        "Operation {} timed out after {}ms",
                        operation, timeout_ms
                    )
                }
                SafeTestError::CalculationFailed { operation, details } => {
                    write!(f, "Calculation failed for {}: {}", operation, details)
                }
            }
        }
    }

    impl std::error::Error for SafeTestError {}

    /// Safe assertion function that never panics
    pub fn safe_assert(
        condition: bool,
        field: &str,
        expected: &str,
        actual: impl std::fmt::Display,
    ) -> SafeTestResult<()> {
        if condition {
            Ok(())
        } else {
            Err(SafeTestError::AssertionFailed {
                field: field.to_string(),
                expected: expected.to_string(),
                actual: actual.to_string(),
            })
        }
    }

    /// Safe equality assertion
    pub fn safe_assert_eq<T: PartialEq + std::fmt::Debug>(
        actual: &T,
        expected: &T,
        field: &str,
    ) -> SafeTestResult<()> {
        if actual == expected {
            Ok(())
        } else {
            Err(SafeTestError::AssertionFailed {
                field: field.to_string(),
                expected: format!("{:?}", expected),
                actual: format!("{:?}", actual),
            })
        }
    }
}

// Mock implementations for testing
pub mod mocks {
    //! Mock implementations for testing purposes

    use super::*;

    /// Mock market data provider
    #[derive(Debug, Clone)]
    pub struct MockMarketDataProvider {
        /// Current price for symbols
        pub prices: Arc<RwLock<HashMap<String, Decimal>>>,
    }

    impl MockMarketDataProvider {
        /// Create new mock provider
        pub fn new() -> Self {
            let mut prices = HashMap::new();
            prices.insert("BTCUSD".to_string(), Decimal::from(50000));
            prices.insert("ETHUSD".to_string(), Decimal::from(3000));

            Self {
                prices: Arc::new(RwLock::new(prices)),
            }
        }

        /// Set price for symbol
        pub async fn set_price(&self, symbol: &str, price: Decimal) {
            let mut prices = self.prices.write().await;
            prices.insert(symbol.to_string(), price);
        }

        /// Get price for symbol
        pub async fn get_price(&self, symbol: &str) -> Option<Decimal> {
            let prices = self.prices.read().await;
            prices.get(symbol).copied()
        }
    }

    impl Default for MockMarketDataProvider {
        fn default() -> Self {
            Self::new()
        }
    }
}

// Test configuration
pub mod config {
    //! Test configuration utilities

    use super::*;

    /// Test configuration
    #[derive(Debug, Clone)]
    pub struct TestConfig {
        /// Initial capital for testing
        pub initial_capital: Decimal,
        /// Test symbols to use
        pub test_symbols: Vec<String>,
        /// Enable test logging
        pub enable_logging: bool,
        /// Test timeout in seconds
        pub timeout_seconds: u64,
        /// Maximum number of test retries
        pub max_retries: u32,
    }

    impl Default for TestConfig {
        fn default() -> Self {
            Self {
                initial_capital: Decimal::from(100000),
                test_symbols: vec!["BTCUSD".to_string(), "ETHUSD".to_string()],
                enable_logging: false,
                timeout_seconds: 30,
                max_retries: 3,
            }
        }
    }

    /// Load test configuration from environment
    pub fn load_test_config() -> TestConfig {
        TestConfig {
            initial_capital: std::env::var("TEST_INITIAL_CAPITAL")
                .ok()
                .and_then(|s| s.parse::<i64>().ok())
                .map(Decimal::from)
                .unwrap_or(Decimal::from(100000)),
            test_symbols: std::env::var("TEST_SYMBOLS")
                .unwrap_or_else(|_| "BTCUSD,ETHUSD".to_string())
                .split(',')
                .map(|s| s.trim().to_string())
                .collect(),
            enable_logging: std::env::var("TEST_ENABLE_LOGGING")
                .map(|s| s.to_lowercase() == "true")
                .unwrap_or(false),
            timeout_seconds: std::env::var("TEST_TIMEOUT_SECONDS")
                .ok()
                .and_then(|s| s.parse().ok())
                .unwrap_or(30),
            max_retries: std::env::var("TEST_MAX_RETRIES")
                .ok()
                .and_then(|s| s.parse().ok())
                .unwrap_or(3),
        }
    }
}

// Utility functions moved to utils/ module to avoid conflicts

// Re-export common items for convenience
pub use config::*;// pub use framework::*;
// pub use helpers::*;
pub use foxhunt_config_crate::*;
pub use mocks::*;
pub use performance_utils::*;
pub use safety::*;
// Re-export utils items individually to avoid naming conflicts
pub use utils::{get_test_config, TestConfig};

// Generate a simple test ID (copied from helpers.rs for lib.rs tests)
fn generate_test_id() -> String {
    use std::sync::atomic::{AtomicU64, Ordering};
    static COUNTER: AtomicU64 = AtomicU64::new(1);
    format!("TEST_{}", COUNTER.fetch_add(1, Ordering::SeqCst))
}

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

    #[test]
    fn test_lib_imports() {
        // Test that all imports work correctly
        let _config = TestConfig::default();
        let _id = generate_test_id();
        assert!(true);
    }

    #[tokio::test]
    async fn test_async_utils() {
        // Test async utilities
        let provider = MockMarketDataProvider::new();
        provider.set_price("TESTUSD", Decimal::from(12345)).await;
        let price = provider.get_price("TESTUSD").await;
        assert_eq!(price, Some(Decimal::from(12345)));
    }
}