//! HFT Specific Test Utilities
//!
//! Specialized testing utilities for high frequency trading components
//! with focus on performance, latency, and financial accuracy.

use super::test_safety::{TestError, TestResult};
use chrono::{DateTime, Utc};
use foxhunt_core::types::prelude::*;
use std::collections::VecDeque;
use std::time::{Duration, Instant};

/// Performance measurement utilities for HFT testing
pub mod performance {
    use super::*;

    /// Latency measurement with statistical analysis
    pub struct LatencyMeasurement {
        measurements: VecDeque<Duration>,
        max_samples: usize,
    }

    impl LatencyMeasurement {
        pub fn new(max_samples: usize) -> Self {
            Self {
                measurements: VecDeque::with_capacity(max_samples),
                max_samples,
            }
        }

        pub fn record(&mut self, latency: Duration) {
            if self.measurements.len() >= self.max_samples {
                self.measurements.pop_front();
            }
            self.measurements.push_back(latency);
        }

        pub fn average(&self) -> Option<Duration> {
            if self.measurements.is_empty() {
                return None;
            }

            let total_nanos: u64 = self.measurements.iter().map(|d| d.as_nanos() as u64).sum();

            Some(Duration::from_nanos(
                total_nanos / self.measurements.len() as u64,
            ))
        }

        pub fn percentile(&self, p: f64) -> Option<Duration> {
            if self.measurements.is_empty() {
                return None;
            }

            let mut sorted: Vec<Duration> = self.measurements.iter().copied().collect();
            sorted.sort();

            let index = ((sorted.len() as f64 - 1.0) * p).round() as usize;
            sorted.get(index).copied()
        }

        pub fn max(&self) -> Option<Duration> {
            self.measurements.iter().max().copied()
        }

        pub fn min(&self) -> Option<Duration> {
            self.measurements.iter().min().copied()
        }
    }

    /// Measure operation latency with safety checks
    pub async fn measure_latency<F, T, Fut>(
        operation: F,
        context: &str,
    ) -> TestResult<(T, Duration)>
    where
        F: FnOnce() -> Fut,
        Fut: std::future::Future<Output = TestResult<T>>,
    {
        let start = Instant::now();
        let result = operation().await?;
        let latency = start.elapsed();

        println!("Operation '{}' completed in {:?}", context, latency);
        Ok((result, latency))
    }

    /// Validate HFT latency requirements (sub-microsecond)
    pub fn validate_hft_latency(
        latency: Duration,
        max_allowed: Duration,
        context: &str,
    ) -> TestResult<()> {
        if latency > max_allowed {
            return Err(TestError::assertion(format!(
                "{}: Latency {:?} exceeds HFT requirement of {:?}",
                context, latency, max_allowed
            )));
        }
        Ok(())
    }

    /// Benchmark operation with warmup and multiple iterations
    pub async fn benchmark_operation<F, T, Fut>(
        operation: F,
        warmup_iterations: usize,
        measurement_iterations: usize,
        context: &str,
    ) -> TestResult<LatencyMeasurement>
    where
        F: Fn() -> Fut + Clone,
        Fut: std::future::Future<Output = TestResult<T>>,
    {
        // Warmup phase
        for _ in 0..warmup_iterations {
            operation().await.map_err(|e| {
                TestError::setup(format!("Benchmark warmup failed for {}: {}", context, e))
            })?;
        }

        // Measurement phase
        let mut measurements = LatencyMeasurement::new(measurement_iterations);
        for _ in 0..measurement_iterations {
            let (_, latency) = measure_latency(operation.clone(), context).await?;
            measurements.record(latency);
        }

        Ok(measurements)
    }
}

/// Financial accuracy testing utilities
pub mod financial {
    use super::*;

    /// Precision threshold for financial calculations
    pub const FINANCIAL_PRECISION: f64 = 1e-8;

    /// Safe comparison of financial amounts with precision handling
    pub fn assert_decimal_eq(left: Decimal, right: Decimal, context: &str) -> TestResult<()> {
        let diff = (left - right).abs();
        let precision_decimal = Decimal::from_f64(FINANCIAL_PRECISION)
            .ok_or_else(|| TestError::setup("Failed to create precision decimal"))?;

        if diff > precision_decimal {
            return Err(TestError::assertion(format!(
                "{}: Financial amounts not equal within precision\n  left: {}\n  right: {}\n  diff: {}\n  max_allowed: {}",
                context, left, right, diff, precision_decimal
            )));
        }
        Ok(())
    }

    /// Generate test prices with realistic market behavior
    pub fn generate_realistic_prices(
        base_price: Decimal,
        count: usize,
        volatility: f64,
    ) -> TestResult<Vec<Decimal>> {
        use rand::Rng;
        let mut rng = rand::thread_rng();
        let mut prices = Vec::with_capacity(count);
        let mut current_price = base_price;

        for _ in 0..count {
            let change_pct = rng.gen_range(-volatility..volatility);
            let change_decimal = Decimal::from_f64(change_pct / 100.0)
                .ok_or_else(|| TestError::setup("Failed to create change decimal"))?;
            let change = current_price * change_decimal;
            current_price =
                (current_price + change).max(Decimal::from_f64(0.01).unwrap_or_default());
            prices.push(current_price);
        }

        Ok(prices)
    }
}

/// Market data testing utilities
pub mod market_data {
    use super::*;

    /// Mock market data tick for testing
    #[derive(Debug, Clone)]
    pub struct TestTick {
        pub symbol: String,
        pub timestamp: DateTime<Utc>,
        pub price: Decimal,
        pub volume: Decimal,
        pub bid: Option<Decimal>,
        pub ask: Option<Decimal>,
    }

    impl TestTick {
        pub fn new(symbol: &str, price: Decimal, volume: Decimal) -> Self {
            Self {
                symbol: symbol.to_string(),
                timestamp: Utc::now(),
                price,
                volume,
                bid: None,
                ask: None,
            }
        }

        pub fn with_spread(mut self, bid: Decimal, ask: Decimal) -> Self {
            self.bid = Some(bid);
            self.ask = Some(ask);
            self
        }
    }

    /// Generate realistic market data stream for testing
    pub struct TestMarketDataStream {
        symbols: Vec<String>,
        base_prices: std::collections::HashMap<String, Decimal>,
        tick_rate_hz: u64,
    }

    impl TestMarketDataStream {
        pub fn new(symbols: Vec<String>, tick_rate_hz: u64) -> Self {
            let mut base_prices = std::collections::HashMap::new();
            for symbol in &symbols {
                // Set realistic base prices for different asset types
                let base_price = match symbol.as_str() {
                    s if s.contains("USD") => Decimal::from_f64(1.2).unwrap_or_default(),
                    s if s.starts_with("BTC") => Decimal::from_f64(45000.0).unwrap_or_default(),
                    _ => Decimal::from_f64(100.0).unwrap_or_default(), // Default stock price
                };
                base_prices.insert(symbol.clone(), base_price);
            }

            Self {
                symbols,
                base_prices,
                tick_rate_hz,
            }
        }

        pub async fn generate_ticks(&self, duration: Duration) -> TestResult<Vec<TestTick>> {
            let total_ticks = (duration.as_secs_f64() * self.tick_rate_hz as f64) as usize;
            let mut ticks = Vec::with_capacity(total_ticks);
            let tick_interval = Duration::from_nanos(1_000_000_000 / self.tick_rate_hz);

            for i in 0..total_ticks {
                for symbol in &self.symbols {
                    let base_price = self.base_prices.get(symbol).ok_or_else(|| {
                        TestError::setup(format!("No base price for symbol {}", symbol))
                    })?;

                    // Add small random variation
                    let variation = (i as f64 * 0.001).sin() * 0.001; // Small deterministic variation
                    let variation_decimal = Decimal::from_f64(variation).unwrap_or_default();
                    let price = *base_price * (Decimal::ONE + variation_decimal);

                    let volume = Decimal::from((100 + i) % 1000);
                    let tick = TestTick::new(symbol, price, volume);
                    ticks.push(tick);
                }

                // Simulate real-time tick generation
                if i % 100 == 0 {
                    tokio::time::sleep(tick_interval).await;
                }
            }

            Ok(ticks)
        }
    }

    /// Validate market data consistency
    pub fn validate_tick_sequence(ticks: &[TestTick], context: &str) -> TestResult<()> {
        if ticks.is_empty() {
            return Err(TestError::assertion(format!(
                "{}: Empty tick sequence",
                context
            )));
        }

        // Check timestamp ordering
        for window in ticks.windows(2) {
            if window[1].timestamp < window[0].timestamp {
                return Err(TestError::assertion(format!(
                    "{}: Timestamps out of order: {} -> {}",
                    context, window[0].timestamp, window[1].timestamp
                )));
            }
        }

        // Check for unrealistic price movements (>50% in single tick)
        for window in ticks.windows(2) {
            if window[0].symbol == window[1].symbol {
                let price_change = ((window[1].price - window[0].price) / window[0].price).abs();
                let fifty_percent = Decimal::from_f64(0.5).unwrap_or_default();
                if price_change > fifty_percent {
                    return Err(TestError::assertion(format!(
                        "{}: Unrealistic price movement in {}: {} -> {} ({:.2}%)",
                        context,
                        window[0].symbol,
                        window[0].price,
                        window[1].price,
                        price_change * Decimal::from(100)
                    )));
                }
            }
        }

        Ok(())
    }
}

/// Order management testing utilities
pub mod orders {
    use super::*;

    /// Mock order for testing
    #[derive(Debug, Clone)]
    pub struct TestOrder {
        pub id: String,
        pub symbol: String,
        pub side: OrderSide,
        pub quantity: Decimal,
        pub price: Option<Decimal>,
        pub order_type: OrderType,
        pub status: OrderStatus,
        pub created_at: DateTime<Utc>,
        pub filled_quantity: Decimal,
        pub avg_fill_price: Option<Decimal>,
    }

    #[derive(Debug, Clone, PartialEq)]
    pub enum OrderSide {
        Buy,
        Sell,
    }

    #[derive(Debug, Clone, PartialEq)]
    pub enum OrderType {
        Market,
        Limit,
        Stop,
        StopLimit,
    }

    #[derive(Debug, Clone, PartialEq)]
    pub enum OrderStatus {
        New,
        Pending,
        PartiallyFilled,
        Filled,
        Cancelled,
        Rejected,
    }

    impl TestOrder {
        pub fn new_market_order(symbol: &str, side: OrderSide, quantity: Decimal) -> Self {
            Self {
                id: uuid::Uuid::new_v4().to_string(),
                symbol: symbol.to_string(),
                side,
                quantity,
                price: None,
                order_type: OrderType::Market,
                status: OrderStatus::New,
                created_at: Utc::now(),
                filled_quantity: Decimal::ZERO,
                avg_fill_price: None,
            }
        }

        pub fn new_limit_order(
            symbol: &str,
            side: OrderSide,
            quantity: Decimal,
            price: Decimal,
        ) -> Self {
            Self {
                id: uuid::Uuid::new_v4().to_string(),
                symbol: symbol.to_string(),
                side,
                quantity,
                price: Some(price),
                order_type: OrderType::Limit,
                status: OrderStatus::New,
                created_at: Utc::now(),
                filled_quantity: Decimal::ZERO,
                avg_fill_price: None,
            }
        }

        pub fn simulate_fill(
            &mut self,
            fill_quantity: Decimal,
            fill_price: Decimal,
        ) -> TestResult<()> {
            if fill_quantity <= Decimal::ZERO {
                return Err(TestError::assertion("Fill quantity must be positive"));
            }

            if self.filled_quantity + fill_quantity > self.quantity {
                return Err(TestError::assertion(format!(
                    "Fill quantity {} would exceed order quantity {}",
                    fill_quantity, self.quantity
                )));
            }

            // Update average fill price
            if self.filled_quantity == Decimal::ZERO {
                self.avg_fill_price = Some(fill_price);
            } else {
                let current_avg = self.avg_fill_price.unwrap_or_default();
                let total_value = current_avg * self.filled_quantity + fill_price * fill_quantity;
                let new_total_quantity = self.filled_quantity + fill_quantity;
                self.avg_fill_price = Some(total_value / new_total_quantity);
            }

            self.filled_quantity += fill_quantity;

            // Update status
            if self.filled_quantity == self.quantity {
                self.status = OrderStatus::Filled;
            } else {
                self.status = OrderStatus::PartiallyFilled;
            }

            Ok(())
        }
    }

    /// Validate order lifecycle transitions
    pub fn validate_order_lifecycle(orders: &[TestOrder], context: &str) -> TestResult<()> {
        for order in orders {
            // Validate filled quantity doesn't exceed order quantity
            if order.filled_quantity > order.quantity {
                return Err(TestError::assertion(format!(
                    "{}: Order {} filled quantity {} exceeds order quantity {}",
                    context, order.id, order.filled_quantity, order.quantity
                )));
            }

            // Validate status consistency
            match order.status {
                OrderStatus::Filled if order.filled_quantity != order.quantity => {
                    return Err(TestError::assertion(format!(
                        "{}: Order {} marked as filled but quantities don't match: {} != {}",
                        context, order.id, order.filled_quantity, order.quantity
                    )));
                }
                OrderStatus::PartiallyFilled if order.filled_quantity == Decimal::ZERO => {
                    return Err(TestError::assertion(format!(
                        "{}: Order {} marked as partially filled but no quantity filled",
                        context, order.id
                    )));
                }
                _ => {}
            }
        }

        Ok(())
    }
}

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

    #[tokio::test]
    async fn test_latency_measurement() -> TestResult<()> {
        let mut measurement = performance::LatencyMeasurement::new(100);

        for i in 1..=10 {
            measurement.record(Duration::from_nanos(i * 1000));
        }

        let avg = measurement.average().expect("Should have average");
        assert!(avg > Duration::from_nanos(5000));
        assert!(avg < Duration::from_nanos(6000));

        Ok(())
    }

    #[tokio::test]
    async fn test_financial_precision() -> TestResult<()> {
        let price1 = Decimal::from_f64(100.12345678).unwrap_or_default();
        let price2 = Decimal::from_f64(100.12345679).unwrap_or_default();

        // Should pass within precision
        financial::assert_decimal_eq(price1, price2, "price comparison")?;

        Ok(())
    }

    #[tokio::test]
    async fn test_market_data_generation() -> TestResult<()> {
        let stream = market_data::TestMarketDataStream::new(
            vec!["AAPL".to_string(), "GOOGL".to_string()],
            1000, // 1000 Hz
        );

        let ticks = stream.generate_ticks(Duration::from_millis(10)).await?;
        assert!(!ticks.is_empty());

        market_data::validate_tick_sequence(&ticks, "test market data")?;

        Ok(())
    }

    #[tokio::test]
    async fn test_order_simulation() -> TestResult<()> {
        let mut order = orders::TestOrder::new_limit_order(
            "AAPL",
            orders::OrderSide::Buy,
            Decimal::from(100),
            Decimal::from_f64(150.0).unwrap_or_default(),
        );

        // Simulate partial fill
        order.simulate_fill(
            Decimal::from(50),
            Decimal::from_f64(149.5).unwrap_or_default(),
        )?;

        assert_eq!(order.status, orders::OrderStatus::PartiallyFilled);
        assert_eq!(order.filled_quantity, Decimal::from(50));

        // Complete the fill
        order.simulate_fill(
            Decimal::from(50),
            Decimal::from_f64(150.5).unwrap_or_default(),
        )?;

        assert_eq!(order.status, orders::OrderStatus::Filled);
        assert_eq!(order.filled_quantity, Decimal::from(100));

        Ok(())
    }
}