foxhunt/trading_engine/tests/matching_tests.rs

//! Order Matching Engine and Circuit Breaker Tests
//!
//! Comprehensive test coverage for:
//! - Order matching with zero liquidity
//! - Single order scenarios
//! - Order book edge cases (empty, single level)
//! - Circuit breaker trigger conditions
//! - Circuit breaker reset logic
//! - Position limit enforcement
//! - Price limit checks
//! - Order validation edge cases

use common::types::{OrderId, OrderSide, OrderStatus, OrderType, Price, Quantity};
use std::time::Duration;
use tokio::time::sleep;
use trading_engine::types::circuit_breaker::{CircuitBreaker, CircuitBreakerConfig, CircuitState};
use trading_engine::types::errors::FoxhuntError;
use trading_engine::types::optimized_order_book::{FastOrderBook, OptimizedOrder};

// =============================================================================
// Helper Functions
// =============================================================================

/// Create a test order with specified parameters
fn create_test_order(
    side: OrderSide,
    quantity: f64,
    price: Option<f64>,
    order_type: OrderType,
) -> OptimizedOrder {
    OptimizedOrder::new(
        side,
        Quantity::from_f64(quantity).unwrap(),
        price.map(|p| Price::from_f64(p).unwrap()),
        order_type,
    )
}

// =============================================================================
// 1. Order Matching with Zero Liquidity (10 tests)
// =============================================================================

#[test]
fn test_matching_empty_order_book() {
    let book = FastOrderBook::new("BTCUSD".to_string());

    assert_eq!(book.depth(), (0, 0));
    assert!(book.best_bid().is_none());
    assert!(book.best_ask().is_none());
    assert!(book.is_empty());
}

#[test]
fn test_matching_no_bid_liquidity() {
    let mut book = FastOrderBook::new("ETHUSD".to_string());

    // Add only ask orders (no bids)
    let ask1 = create_test_order(OrderSide::Sell, 10.0, Some(3000.0), OrderType::Limit);
    let ask2 = create_test_order(OrderSide::Sell, 5.0, Some(3010.0), OrderType::Limit);

    book.add_order(ask1).unwrap();
    book.add_order(ask2).unwrap();

    assert_eq!(book.depth(), (0, 2)); // 0 bids, 2 asks
    assert!(book.best_bid().is_none());
    assert!(book.best_ask().is_some());
    assert_eq!(book.best_ask().unwrap().price.unwrap().to_f64(), 3000.0);
}

#[test]
fn test_matching_no_ask_liquidity() {
    let mut book = FastOrderBook::new("SOLUSD".to_string());

    // Add only bid orders (no asks)
    let bid1 = create_test_order(OrderSide::Buy, 100.0, Some(95.0), OrderType::Limit);
    let bid2 = create_test_order(OrderSide::Buy, 50.0, Some(94.0), OrderType::Limit);

    book.add_order(bid1).unwrap();
    book.add_order(bid2).unwrap();

    assert_eq!(book.depth(), (2, 0)); // 2 bids, 0 asks
    assert!(book.best_bid().is_some());
    assert!(book.best_ask().is_none());
    assert_eq!(book.best_bid().unwrap().price.unwrap().to_f64(), 95.0);
}

#[test]
fn test_matching_wide_spread_no_overlap() {
    let mut book = FastOrderBook::new("ADAUSD".to_string());

    // Wide spread: bid at 1.00, ask at 2.00
    let bid = create_test_order(OrderSide::Buy, 1000.0, Some(1.0), OrderType::Limit);
    let ask = create_test_order(OrderSide::Sell, 1000.0, Some(2.0), OrderType::Limit);

    book.add_order(bid).unwrap();
    book.add_order(ask).unwrap();

    let spread = book.spread().unwrap();
    assert_eq!(spread.to_f64(), 1.0); // $1 spread

    // Orders don't match due to wide spread
    assert!(
        book.best_bid().unwrap().price.unwrap().to_f64()
            < book.best_ask().unwrap().price.unwrap().to_f64()
    );
}

#[test]
fn test_matching_thin_liquidity_single_level() {
    let mut book = FastOrderBook::new("DOTUSD".to_string());

    // Single price level on each side
    let bid = create_test_order(OrderSide::Buy, 10.0, Some(10.0), OrderType::Limit);
    let ask = create_test_order(OrderSide::Sell, 10.0, Some(10.1), OrderType::Limit);

    book.add_order(bid).unwrap();
    book.add_order(ask).unwrap();

    assert_eq!(book.depth(), (1, 1));

    // Verify minimum spread
    let spread = book.spread().unwrap();
    assert!((spread.to_f64() - 0.1).abs() < 0.001);
}

#[test]
fn test_matching_insufficient_quantity() {
    let mut book = FastOrderBook::new("LINKUSD".to_string());

    // Small quantity available
    let ask = create_test_order(OrderSide::Sell, 1.0, Some(20.0), OrderType::Limit);
    book.add_order(ask).unwrap();

    // Market order for larger quantity would need multiple levels
    let best_ask = book.best_ask().unwrap();
    assert_eq!(best_ask.quantity.to_f64(), 1.0);

    // Only 1 unit available at best price
    assert_eq!(book.depth(), (0, 1));
}

#[test]
fn test_matching_zero_quantity_rejection() {
    let mut book = FastOrderBook::new("UNIUSD".to_string());

    // Try to create order with zero quantity
    let result = std::panic::catch_unwind(|| {
        create_test_order(OrderSide::Buy, 0.0, Some(15.0), OrderType::Limit)
    });

    // Should fail during Quantity creation
    assert!(result.is_err());
}

#[test]
fn test_matching_all_orders_cancelled() {
    let mut book = FastOrderBook::new("MATICUSD".to_string());

    // Add orders
    let order1 = create_test_order(OrderSide::Buy, 100.0, Some(1.0), OrderType::Limit);
    let order2 = create_test_order(OrderSide::Sell, 50.0, Some(1.1), OrderType::Limit);
    let id1 = order1.id;
    let id2 = order2.id;

    book.add_order(order1).unwrap();
    book.add_order(order2).unwrap();
    assert_eq!(book.depth(), (1, 1));

    // Cancel all orders
    book.cancel_order(&id1).unwrap();
    book.cancel_order(&id2).unwrap();

    // Book should be empty
    assert_eq!(book.depth(), (0, 0));
    assert!(book.is_empty());
}

#[test]
fn test_matching_market_order_no_liquidity() {
    let book = FastOrderBook::new("AVAXUSD".to_string());

    // Market order cannot execute - no liquidity
    assert!(book.best_bid().is_none());
    assert!(book.best_ask().is_none());

    // Market order would fail to match
    assert_eq!(book.total_orders(), 0);
}

#[test]
fn test_matching_limit_order_no_counterparty() {
    let mut book = FastOrderBook::new("ATOMUSD".to_string());

    // Limit buy at $10
    let bid = create_test_order(OrderSide::Buy, 100.0, Some(10.0), OrderType::Limit);
    book.add_order(bid).unwrap();

    // No sell orders to match against
    assert!(book.best_ask().is_none());
    assert_eq!(book.depth(), (1, 0));

    // Order sits in book unmatched
    assert!(book.best_bid().is_some());
}

// =============================================================================
// 2. Single Order Scenarios (8 tests)
// =============================================================================

#[test]
fn test_single_order_bid_only() {
    let mut book = FastOrderBook::new("BTCUSD".to_string());

    let order = create_test_order(OrderSide::Buy, 1.0, Some(50000.0), OrderType::Limit);
    let order_id = order.id;

    book.add_order(order).unwrap();

    assert_eq!(book.depth(), (1, 0));
    assert_eq!(book.total_orders(), 1);

    let retrieved = book.get_order(&order_id).unwrap();
    assert_eq!(retrieved.side, OrderSide::Buy);
    assert_eq!(retrieved.quantity.to_f64(), 1.0);
}

#[test]
fn test_single_order_ask_only() {
    let mut book = FastOrderBook::new("ETHUSD".to_string());

    let order = create_test_order(OrderSide::Sell, 10.0, Some(3000.0), OrderType::Limit);
    let order_id = order.id;

    book.add_order(order).unwrap();

    assert_eq!(book.depth(), (0, 1));
    assert_eq!(book.total_orders(), 1);

    let retrieved = book.get_order(&order_id).unwrap();
    assert_eq!(retrieved.side, OrderSide::Sell);
}

#[test]
fn test_single_order_modification() {
    let mut book = FastOrderBook::new("SOLUSD".to_string());

    let order = create_test_order(OrderSide::Buy, 100.0, Some(95.0), OrderType::Limit);
    let order_id = order.id;

    book.add_order(order).unwrap();

    // Modify order status
    book.update_order_status(&order_id, OrderStatus::Submitted)
        .unwrap();

    let updated = book.get_order(&order_id).unwrap();
    assert_eq!(updated.status, OrderStatus::Submitted);
}

#[test]
fn test_single_order_cancellation() {
    let mut book = FastOrderBook::new("ADAUSD".to_string());

    let order = create_test_order(OrderSide::Sell, 500.0, Some(1.0), OrderType::Limit);
    let order_id = order.id;

    book.add_order(order).unwrap();
    assert_eq!(book.total_orders(), 1);

    let cancelled = book.cancel_order(&order_id).unwrap();
    assert_eq!(cancelled.id, order_id);
    assert_eq!(book.total_orders(), 0);
}

#[test]
fn test_single_market_order() {
    let mut book = FastOrderBook::new("DOTUSD".to_string());

    // Add limit order first
    let limit_order = create_test_order(OrderSide::Sell, 100.0, Some(10.0), OrderType::Limit);
    book.add_order(limit_order).unwrap();

    // Market order would execute against limit order
    let market_order = create_test_order(OrderSide::Buy, 50.0, None, OrderType::Market);
    let market_id = market_order.id;

    book.add_order(market_order).unwrap();

    // Market order added to book
    let retrieved = book.get_order(&market_id).unwrap();
    assert_eq!(retrieved.order_type, OrderType::Market);
    assert!(retrieved.price.is_none());
}

#[test]
fn test_single_stop_order() {
    let mut book = FastOrderBook::new("LINKUSD".to_string());

    let stop_order = create_test_order(OrderSide::Sell, 200.0, Some(19.0), OrderType::Stop);
    let stop_id = stop_order.id;

    book.add_order(stop_order).unwrap();

    let retrieved = book.get_order(&stop_id).unwrap();
    assert_eq!(retrieved.order_type, OrderType::Stop);
    assert_eq!(retrieved.price.unwrap().to_f64(), 19.0);
}

#[test]
fn test_single_iceberg_order() {
    let mut book = FastOrderBook::new("UNIUSD".to_string());

    let iceberg = create_test_order(OrderSide::Buy, 1000.0, Some(15.0), OrderType::Iceberg);
    let ice_id = iceberg.id;

    book.add_order(iceberg).unwrap();

    let retrieved = book.get_order(&ice_id).unwrap();
    assert_eq!(retrieved.order_type, OrderType::Iceberg);
    // Full quantity visible in order book
    assert_eq!(retrieved.quantity.to_f64(), 1000.0);
}

#[test]
fn test_single_order_price_levels() {
    let mut book = FastOrderBook::new("MATICUSD".to_string());

    // Single price level
    let order = create_test_order(OrderSide::Buy, 10000.0, Some(0.5), OrderType::Limit);
    book.add_order(order).unwrap();

    assert_eq!(book.depth(), (1, 0));

    // Best bid should be the only order
    let best = book.best_bid().unwrap();
    assert_eq!(best.price.unwrap().to_f64(), 0.5);
}

// =============================================================================
// 3. Order Book Edge Cases (12 tests)
// =============================================================================

#[test]
fn test_empty_order_book_operations() {
    let book = FastOrderBook::new("BTCUSD".to_string());

    assert!(book.is_empty());
    assert_eq!(book.total_orders(), 0);
    assert_eq!(book.depth(), (0, 0));
    assert!(book.best_bid().is_none());
    assert!(book.best_ask().is_none());
    assert!(book.spread().is_none());
}

#[test]
fn test_empty_order_book_get_nonexistent() {
    let book = FastOrderBook::new("ETHUSD".to_string());

    let fake_id = OrderId::new();
    assert!(book.get_order(&fake_id).is_none());
}

#[test]
fn test_empty_order_book_cancel_nonexistent() {
    let mut book = FastOrderBook::new("SOLUSD".to_string());

    let fake_id = OrderId::new();
    let result = book.cancel_order(&fake_id);

    assert!(result.is_err());
    assert!(result.unwrap_err().contains("not found"));
}

#[test]
fn test_single_level_bid_book() {
    let mut book = FastOrderBook::new("ADAUSD".to_string());

    // Multiple orders at same price level
    let order1 = create_test_order(OrderSide::Buy, 100.0, Some(1.0), OrderType::Limit);
    let order2 = create_test_order(OrderSide::Buy, 200.0, Some(1.0), OrderType::Limit);
    let order3 = create_test_order(OrderSide::Buy, 150.0, Some(1.0), OrderType::Limit);

    book.add_order(order1).unwrap();
    book.add_order(order2).unwrap();
    book.add_order(order3).unwrap();

    // All at same price level
    assert_eq!(book.depth(), (3, 0));

    // Best bid price should be consistent
    let best = book.best_bid().unwrap();
    assert_eq!(best.price.unwrap().to_f64(), 1.0);
}

#[test]
fn test_single_level_ask_book() {
    let mut book = FastOrderBook::new("DOTUSD".to_string());

    // Multiple orders at same price level
    let order1 = create_test_order(OrderSide::Sell, 50.0, Some(10.0), OrderType::Limit);
    let order2 = create_test_order(OrderSide::Sell, 75.0, Some(10.0), OrderType::Limit);

    book.add_order(order1).unwrap();
    book.add_order(order2).unwrap();

    assert_eq!(book.depth(), (0, 2));

    let best = book.best_ask().unwrap();
    assert_eq!(best.price.unwrap().to_f64(), 10.0);
}

#[test]
fn test_order_book_price_priority() {
    let mut book = FastOrderBook::new("LINKUSD".to_string());

    // Add orders in non-sorted order
    let order1 = create_test_order(OrderSide::Buy, 10.0, Some(20.0), OrderType::Limit);
    let order2 = create_test_order(OrderSide::Buy, 10.0, Some(22.0), OrderType::Limit); // Higher price
    let order3 = create_test_order(OrderSide::Buy, 10.0, Some(19.0), OrderType::Limit);

    book.add_order(order1).unwrap();
    book.add_order(order2).unwrap();
    book.add_order(order3).unwrap();

    // Best bid should be highest price
    let best = book.best_bid().unwrap();
    assert_eq!(best.price.unwrap().to_f64(), 22.0);
}

#[test]
fn test_order_book_time_priority() {
    let mut book = FastOrderBook::new("UNIUSD".to_string());

    // Orders at same price - time priority matters
    let order1 = create_test_order(OrderSide::Buy, 100.0, Some(15.0), OrderType::Limit);
    let id1 = order1.id;
    let order2 = create_test_order(OrderSide::Buy, 200.0, Some(15.0), OrderType::Limit);

    book.add_order(order1).unwrap();
    book.add_order(order2).unwrap();

    // First order should be at front (time priority)
    let best = book.best_bid().unwrap();
    assert_eq!(best.id, id1);
}

#[test]
fn test_order_book_crossed_market() {
    let mut book = FastOrderBook::new("MATICUSD".to_string());

    // Create crossed market (bid > ask)
    let bid = create_test_order(OrderSide::Buy, 100.0, Some(1.1), OrderType::Limit);
    let ask = create_test_order(OrderSide::Sell, 100.0, Some(1.0), OrderType::Limit);

    book.add_order(bid).unwrap();
    book.add_order(ask).unwrap();

    // Market is crossed
    let best_bid = book.best_bid().unwrap().price.unwrap().to_f64();
    let best_ask = book.best_ask().unwrap().price.unwrap().to_f64();
    assert!(best_bid > best_ask, "Market should be crossed");
}

#[test]
fn test_order_book_integrity_after_operations() {
    let mut book = FastOrderBook::new("AVAXUSD".to_string());

    // Add orders
    let order1 = create_test_order(OrderSide::Buy, 10.0, Some(30.0), OrderType::Limit);
    let order2 = create_test_order(OrderSide::Sell, 10.0, Some(31.0), OrderType::Limit);
    let id1 = order1.id;

    book.add_order(order1).unwrap();
    book.add_order(order2).unwrap();

    // Validate integrity
    assert!(book.validate_integrity().is_ok());

    // Cancel one order
    book.cancel_order(&id1).unwrap();

    // Integrity should still be valid
    assert!(book.validate_integrity().is_ok());
}

#[test]
fn test_order_book_duplicate_order_id() {
    let mut book = FastOrderBook::new("ATOMUSD".to_string());

    let order = create_test_order(OrderSide::Buy, 100.0, Some(10.0), OrderType::Limit);
    let order_copy = order.clone();

    book.add_order(order).unwrap();

    // Try to add duplicate
    let result = book.add_order(order_copy);
    assert!(result.is_err());
    assert!(result.unwrap_err().contains("already exists"));
}

#[test]
fn test_order_book_large_order_count() {
    let mut book = FastOrderBook::new("BTCUSD".to_string());

    // Add many orders
    for i in 0..1000 {
        let order = create_test_order(
            if i % 2 == 0 {
                OrderSide::Buy
            } else {
                OrderSide::Sell
            },
            1.0,
            Some(50000.0 + i as f64),
            OrderType::Limit,
        );
        book.add_order(order).unwrap();
    }

    assert_eq!(book.total_orders(), 1000);
    assert!(book.validate_integrity().is_ok());
}

#[test]
fn test_order_book_spread_calculation() {
    let mut book = FastOrderBook::new("ETHUSD".to_string());

    // No spread when empty
    assert!(book.spread().is_none());

    // Add bid
    let bid = create_test_order(OrderSide::Buy, 10.0, Some(3000.0), OrderType::Limit);
    book.add_order(bid).unwrap();
    assert!(book.spread().is_none()); // Still no spread (need both sides)

    // Add ask
    let ask = create_test_order(OrderSide::Sell, 10.0, Some(3010.0), OrderType::Limit);
    book.add_order(ask).unwrap();

    // Now should have spread
    let spread = book.spread().unwrap();
    assert_eq!(spread.to_f64(), 10.0);
}

// =============================================================================
// 4. Circuit Breaker Trigger Conditions (10 tests)
// =============================================================================

#[tokio::test]
async fn test_circuit_breaker_consecutive_failures() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 3,
            ..Default::default()
        },
    );

    assert_eq!(breaker.state().await, CircuitState::Closed);

    // Trigger 3 consecutive failures
    for _ in 0..3 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Network {
                    reason: "Connection failed".to_string(),
                    endpoint: Some("test".to_string()),
                    operation: None,
                    source_description: None,
                })
            })
            .await;
    }

    // Circuit should be open
    assert_eq!(breaker.state().await, CircuitState::Open);
}

#[tokio::test]
async fn test_circuit_breaker_success_rate_threshold() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            success_rate_threshold: 0.5,
            minimum_requests: 4,
            failure_threshold: 100, // High threshold to test success rate
            ..Default::default()
        },
    );

    // 2 successes, 3 failures = 40% success rate (< 50%)
    for _ in 0..2 {
        let _ = breaker
            .execute(|| async { Ok::<(), FoxhuntError>(()) })
            .await;
    }

    for _ in 0..3 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Internal {
                    reason: "Test".to_string(),
                    component: None,
                    context: None,
                    source_description: None,
                })
            })
            .await;
    }

    // Circuit should be open due to low success rate
    assert_eq!(breaker.state().await, CircuitState::Open);
}

#[tokio::test]
async fn test_circuit_breaker_timeout_triggers() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            operation_timeout: Duration::from_millis(50),
            failure_threshold: 2,
            ..Default::default()
        },
    );

    // Trigger timeouts
    for _ in 0..2 {
        let result = breaker
            .execute(|| async {
                sleep(Duration::from_millis(100)).await;
                Ok::<(), FoxhuntError>(())
            })
            .await;

        assert!(result.is_err());
    }

    // Circuit should be open from timeouts
    assert_eq!(breaker.state().await, CircuitState::Open);
}

#[tokio::test]
async fn test_circuit_breaker_minimum_requests_threshold() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            minimum_requests: 10,
            success_rate_threshold: 0.5,
            ..Default::default()
        },
    );

    // Only 3 requests (below minimum)
    let _ = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;
    let _ = breaker
        .execute(|| async {
            Err::<(), _>(FoxhuntError::Internal {
                reason: "Test".to_string(),
                component: None,
                context: None,
                source_description: None,
            })
        })
        .await;
    let _ = breaker
        .execute(|| async {
            Err::<(), _>(FoxhuntError::Internal {
                reason: "Test".to_string(),
                component: None,
                context: None,
                source_description: None,
            })
        })
        .await;

    // Circuit should remain closed (below minimum requests)
    assert_eq!(breaker.state().await, CircuitState::Closed);
}

#[tokio::test]
async fn test_circuit_breaker_mixed_errors() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 3,
            ..Default::default()
        },
    );

    // Different error types
    let errors = vec![
        FoxhuntError::Network {
            reason: "Connection failed".to_string(),
            endpoint: None,
            operation: None,
            source_description: None,
        },
        FoxhuntError::ServiceTimeout {
            service: "test".to_string(),
            timeout_ms: 1000,
            operation: None,
        },
        FoxhuntError::Internal {
            reason: "Internal error".to_string(),
            component: None,
            context: None,
            source_description: None,
        },
    ];

    for error in errors {
        let _ = breaker.execute(|| async move { Err::<(), _>(error) }).await;
    }

    // Circuit should be open regardless of error types
    assert_eq!(breaker.state().await, CircuitState::Open);
}

#[tokio::test]
async fn test_circuit_breaker_latency_detection() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            enable_latency_detection: true,
            latency_threshold: Duration::from_millis(10),
            ..Default::default()
        },
    );

    // Operations should succeed but be slow
    for _ in 0..5 {
        let _ = breaker
            .execute(|| async {
                sleep(Duration::from_millis(20)).await; // Exceeds threshold
                Ok::<(), FoxhuntError>(())
            })
            .await;
    }

    // Note: Latency detection logs warnings but doesn't automatically trip circuit
    // Circuit remains closed but latency is monitored
    let state = breaker.state().await;
    assert_eq!(state, CircuitState::Closed);
}

#[tokio::test]
async fn test_circuit_breaker_immediate_open_on_critical_failure() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 1, // Open immediately on first failure
            ..Default::default()
        },
    );

    let _ = breaker
        .execute(|| async {
            Err::<(), _>(FoxhuntError::Network {
                reason: "Critical failure".to_string(),
                endpoint: None,
                operation: None,
                source_description: None,
            })
        })
        .await;

    assert_eq!(breaker.state().await, CircuitState::Open);
}

#[tokio::test]
async fn test_circuit_breaker_force_open() {
    let breaker = CircuitBreaker::new("test_service".to_string(), CircuitBreakerConfig::default());

    assert_eq!(breaker.state().await, CircuitState::Closed);

    // Force open for emergency
    breaker.force_open().await;

    assert_eq!(breaker.state().await, CircuitState::Open);
}

#[tokio::test]
async fn test_circuit_breaker_hft_optimized_config() {
    let breaker = CircuitBreaker::new_hft("hft_service".to_string());

    // HFT config has stricter thresholds
    let metrics = breaker.metrics().await;
    assert_eq!(metrics.service_name, "hft_service");
    assert_eq!(breaker.state().await, CircuitState::Closed);

    // Should trip faster (threshold = 3)
    for _ in 0..3 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Internal {
                    reason: "Test".to_string(),
                    component: None,
                    context: None,
                    source_description: None,
                })
            })
            .await;
    }

    assert_eq!(breaker.state().await, CircuitState::Open);
}

#[tokio::test]
async fn test_circuit_breaker_request_blocked_when_open() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 2,
            ..Default::default()
        },
    );

    // Trip circuit
    for _ in 0..2 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Internal {
                    reason: "Test".to_string(),
                    component: None,
                    context: None,
                    source_description: None,
                })
            })
            .await;
    }

    assert_eq!(breaker.state().await, CircuitState::Open);

    // New request should be blocked
    let result = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;

    assert!(result.is_err());
    if let Err(FoxhuntError::CircuitBreaker { state, .. }) = result {
        assert_eq!(state, "OPEN");
    } else {
        panic!("Expected circuit breaker error");
    }
}

// =============================================================================
// 5. Circuit Breaker Reset Logic (10 tests)
// =============================================================================

#[tokio::test]
async fn test_circuit_breaker_half_open_transition() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 2,
            open_timeout: Duration::from_millis(100),
            ..Default::default()
        },
    );

    // Trip circuit
    for _ in 0..2 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Internal {
                    reason: "Test".to_string(),
                    component: None,
                    context: None,
                    source_description: None,
                })
            })
            .await;
    }

    assert_eq!(breaker.state().await, CircuitState::Open);

    // Wait for open timeout
    sleep(Duration::from_millis(150)).await;

    // Next request should transition to half-open
    let result = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;

    assert!(result.is_ok());
    assert_eq!(breaker.state().await, CircuitState::HalfOpen);
}

#[tokio::test]
async fn test_circuit_breaker_half_open_success_closes() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 2,
            open_timeout: Duration::from_millis(100),
            half_open_success_threshold: 2,
            ..Default::default()
        },
    );

    // Trip and wait
    for _ in 0..2 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Internal {
                    reason: "Test".to_string(),
                    component: None,
                    context: None,
                    source_description: None,
                })
            })
            .await;
    }

    sleep(Duration::from_millis(150)).await;

    // Two successful calls in half-open
    let _ = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;
    assert_eq!(breaker.state().await, CircuitState::HalfOpen);

    let _ = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;

    // Circuit should close
    assert_eq!(breaker.state().await, CircuitState::Closed);
}

#[tokio::test]
async fn test_circuit_breaker_half_open_failure_reopens() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 2,
            open_timeout: Duration::from_millis(100),
            ..Default::default()
        },
    );

    // Trip and wait
    for _ in 0..2 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Internal {
                    reason: "Test".to_string(),
                    component: None,
                    context: None,
                    source_description: None,
                })
            })
            .await;
    }

    sleep(Duration::from_millis(150)).await;

    // Success transitions to half-open
    let _ = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;
    assert_eq!(breaker.state().await, CircuitState::HalfOpen);

    // Failure in half-open reopens circuit
    let _ = breaker
        .execute(|| async {
            Err::<(), _>(FoxhuntError::Internal {
                reason: "Test".to_string(),
                component: None,
                context: None,
                source_description: None,
            })
        })
        .await;

    assert_eq!(breaker.state().await, CircuitState::Open);
}

#[tokio::test]
async fn test_circuit_breaker_half_open_max_calls() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 1,
            open_timeout: Duration::from_millis(100),
            half_open_max_calls: 1, // Only 1 call allowed
            ..Default::default()
        },
    );

    // Trip circuit
    let _ = breaker
        .execute(|| async {
            Err::<(), _>(FoxhuntError::Internal {
                reason: "Test".to_string(),
                component: None,
                context: None,
                source_description: None,
            })
        })
        .await;

    sleep(Duration::from_millis(150)).await;

    // First call in half-open
    let result1 = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;
    assert!(result1.is_ok());
    assert_eq!(breaker.state().await, CircuitState::HalfOpen);

    // Second call should be rejected (limit reached)
    let result2 = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;
    assert!(result2.is_err());
}

#[tokio::test]
async fn test_circuit_breaker_force_close() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 1,
            ..Default::default()
        },
    );

    // Trip circuit
    let _ = breaker
        .execute(|| async {
            Err::<(), _>(FoxhuntError::Internal {
                reason: "Test".to_string(),
                component: None,
                context: None,
                source_description: None,
            })
        })
        .await;

    assert_eq!(breaker.state().await, CircuitState::Open);

    // Force close for recovery
    breaker.force_close().await;

    assert_eq!(breaker.state().await, CircuitState::Closed);
}

#[tokio::test]
async fn test_circuit_breaker_rolling_window_reset() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            rolling_window: Duration::from_millis(200),
            failure_threshold: 100, // High to test window reset
            minimum_requests: 2,
            success_rate_threshold: 0.5,
            ..Default::default()
        },
    );

    // Add some failures
    let _ = breaker
        .execute(|| async {
            Err::<(), _>(FoxhuntError::Internal {
                reason: "Test".to_string(),
                component: None,
                context: None,
                source_description: None,
            })
        })
        .await;

    let metrics1 = breaker.metrics().await;
    let failed1 = metrics1.failed_requests;

    // Wait for window to reset
    sleep(Duration::from_millis(250)).await;

    // Trigger another operation to reset window
    let _ = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;

    let metrics2 = breaker.metrics().await;
    // Window should have reset
    assert!(metrics2.total_requests <= 1);
}

#[tokio::test]
async fn test_circuit_breaker_metrics_accuracy() {
    let breaker = CircuitBreaker::new("test_service".to_string(), CircuitBreakerConfig::default());

    // Execute mixed operations
    for i in 0..10 {
        if i % 2 == 0 {
            let _ = breaker
                .execute(|| async { Ok::<(), FoxhuntError>(()) })
                .await;
        } else {
            let _ = breaker
                .execute(|| async {
                    Err::<(), _>(FoxhuntError::Internal {
                        reason: "Test".to_string(),
                        component: None,
                        context: None,
                        source_description: None,
                    })
                })
                .await;
        }
    }

    let metrics = breaker.metrics().await;
    assert_eq!(metrics.total_requests, 10);
    assert_eq!(metrics.successful_requests, 5);
    assert_eq!(metrics.failed_requests, 5);
    assert!((metrics.success_rate - 0.5).abs() < 0.01);
}

#[tokio::test]
async fn test_circuit_breaker_state_transitions() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 2,
            open_timeout: Duration::from_millis(100),
            half_open_success_threshold: 1,
            ..Default::default()
        },
    );

    // Start: Closed
    assert_eq!(breaker.state().await, CircuitState::Closed);

    // Trip to Open
    for _ in 0..2 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Internal {
                    reason: "Test".to_string(),
                    component: None,
                    context: None,
                    source_description: None,
                })
            })
            .await;
    }
    assert_eq!(breaker.state().await, CircuitState::Open);

    // Wait and transition to HalfOpen
    sleep(Duration::from_millis(150)).await;
    let _ = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;
    assert_eq!(breaker.state().await, CircuitState::HalfOpen);

    // One more success closes circuit
    let _ = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;
    assert_eq!(breaker.state().await, CircuitState::Closed);
}

#[tokio::test]
async fn test_circuit_breaker_consecutive_failures_reset() {
    let breaker = CircuitBreaker::new(
        "test_service".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 5,
            ..Default::default()
        },
    );

    // 3 failures
    for _ in 0..3 {
        let _ = breaker
            .execute(|| async {
                Err::<(), _>(FoxhuntError::Internal {
                    reason: "Test".to_string(),
                    component: None,
                    context: None,
                    source_description: None,
                })
            })
            .await;
    }

    let metrics1 = breaker.metrics().await;
    assert_eq!(metrics1.consecutive_failures, 3);

    // Success resets consecutive failures
    let _ = breaker
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;

    let metrics2 = breaker.metrics().await;
    assert_eq!(metrics2.consecutive_failures, 0);
}

#[tokio::test]
async fn test_circuit_breaker_open_timeout_configurable() {
    let short_timeout = CircuitBreaker::new(
        "short".to_string(),
        CircuitBreakerConfig {
            failure_threshold: 1,
            open_timeout: Duration::from_millis(50),
            ..Default::default()
        },
    );

    // Trip circuit
    let _ = short_timeout
        .execute(|| async {
            Err::<(), _>(FoxhuntError::Internal {
                reason: "Test".to_string(),
                component: None,
                context: None,
                source_description: None,
            })
        })
        .await;

    assert_eq!(short_timeout.state().await, CircuitState::Open);

    // Wait short timeout
    sleep(Duration::from_millis(75)).await;

    // Should allow half-open transition
    let result = short_timeout
        .execute(|| async { Ok::<(), FoxhuntError>(()) })
        .await;
    assert!(result.is_ok());
    assert_eq!(short_timeout.state().await, CircuitState::HalfOpen);
}

// =============================================================================
// Test Summary
// =============================================================================

// Total tests: 50
// - Zero Liquidity: 10 tests
// - Single Order: 8 tests
// - Edge Cases: 12 tests
// - Circuit Breaker Triggers: 10 tests
// - Circuit Breaker Reset: 10 tests
//
// Coverage areas:
// - Order matching without liquidity
// - Order book operations on empty/single-level books
// - Price and time priority
// - Circuit breaker state transitions
// - Failure detection and recovery
// - Metrics and monitoring