//! Comprehensive tests for Common crate helper functions
//!
//! Tests helper functions, conversions, validations, and edge cases across:
//! - Price/Quantity type conversions (f64, Decimal, edge cases)
//! - Trading enum Display implementations
//! - ID types (EventId, FillId, AggregateId)
//! - Decimal extensions (sqrt, conversions)
//! - Threshold constants validation
//! - Edge cases: NaN, Infinity, overflow, boundary values

use common::constants::*;
use common::thresholds;
use common::trading::{
    BookAction, MarketRegime, OrderEventType, OrderSide, OrderType, Quantity as TradingQuantity,
    TickType,
};
use common::types::{
    AggregateId, CommonTypeError, Currency, DecimalExt, EventId, FillId,
    OrderSide as TypesOrderSide, OrderStatus, OrderType as TypesOrderType, Price, Quantity,
    TimeInForce,
};
use rust_decimal::Decimal;
use std::str::FromStr;

// =============================================================================
// Price Type Conversions & Edge Cases
// =============================================================================

#[test]
fn test_price_from_f64_valid() {
    let price = Price::from_f64(100.50).expect("Valid price");
    assert!((price.to_f64() - 100.50).abs() < 1e-6);
}

#[test]
fn test_price_from_f64_zero() {
    let price = Price::from_f64(0.0).expect("Zero price");
    assert_eq!(price, Price::ZERO);
    assert_eq!(price.to_f64(), 0.0);
}

#[test]
fn test_price_from_f64_negative() {
    let result = Price::from_f64(-10.5);
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::InvalidPrice { .. }) => (),
        _ => panic!("Expected InvalidPrice error for negative value"),
    }
}

#[test]
fn test_price_from_f64_nan() {
    let result = Price::from_f64(f64::NAN);
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::InvalidPrice { .. }) => (),
        _ => panic!("Expected InvalidPrice error for NaN"),
    }
}

#[test]
fn test_price_from_f64_infinity() {
    let result = Price::from_f64(f64::INFINITY);
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::InvalidPrice { .. }) => (),
        _ => panic!("Expected InvalidPrice error for Infinity"),
    }
}

#[test]
fn test_price_from_f64_negative_infinity() {
    let result = Price::from_f64(f64::NEG_INFINITY);
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::InvalidPrice { .. }) => (),
        _ => panic!("Expected InvalidPrice error for -Infinity"),
    }
}

#[test]
fn test_price_from_f64_large_value() {
    // Test with a large but reasonable price value
    let large = 1_000_000.0; // 1 million
    let price = Price::from_f64(large).expect("Large price");
    let recovered = price.to_f64();
    assert!((recovered - large).abs() < 0.01); // Allow small rounding
}

#[test]
fn test_price_from_f64_very_small() {
    let small = 0.000001; // 1 micro-unit
    let price = Price::from_f64(small).expect("Very small price");
    let recovered = price.to_f64();
    assert!((recovered - small).abs() < 1e-8);
}

#[test]
fn test_price_precision_loss() {
    // Test precision at 8 decimal places (fixed-point limit)
    let precise = 123.456789012345; // More than 8 decimals
    let price = Price::from_f64(precise).expect("Precise value");
    let recovered = price.to_f64();
    // Should be rounded to 8 decimal places
    assert!((recovered - precise).abs() < 1e-7);
}

#[test]
fn test_price_constants() {
    assert_eq!(Price::ZERO.to_f64(), 0.0);
    assert_eq!(Price::ONE.to_f64(), 1.0);
    assert_eq!(Price::CENT.to_f64(), 0.01);
    // MAX is u64::MAX in internal representation, which translates to a very large f64
    let max_val = Price::MAX.to_f64();
    assert!(max_val > 1e8); // At least 100 million in f64 representation
    assert!(max_val.is_finite()); // Should be finite, not infinity
}

#[test]
fn test_price_arithmetic_add() {
    let p1 = Price::from_f64(100.0).unwrap();
    let p2 = Price::from_f64(50.0).unwrap();
    let sum = p1 + p2;
    assert!((sum.to_f64() - 150.0).abs() < 1e-6);
}

#[test]
fn test_price_arithmetic_sub() {
    let p1 = Price::from_f64(100.0).unwrap();
    let p2 = Price::from_f64(30.0).unwrap();
    let diff = p1 - p2;
    assert!((diff.to_f64() - 70.0).abs() < 1e-6);
}

#[test]
fn test_price_arithmetic_sub_underflow() {
    let p1 = Price::from_f64(10.0).unwrap();
    let p2 = Price::from_f64(30.0).unwrap();
    let diff = p1 - p2; // Should saturate to zero
    assert_eq!(diff, Price::ZERO);
}

#[test]
fn test_price_multiply() {
    let price1 = Price::from_f64(100.0).unwrap();
    let price2 = Price::from_f64(2.5).unwrap();
    let result = price1.multiply(price2).expect("Multiplication");
    assert!((result.to_f64() - 250.0).abs() < 1e-6);
}

#[test]
fn test_price_divide() {
    let price = Price::from_f64(100.0).unwrap();
    let result = price.divide(4.0).expect("Division");
    assert!((result.to_f64() - 25.0).abs() < 1e-6);
}

#[test]
fn test_price_divide_by_zero() {
    let price = Price::from_f64(100.0).unwrap();
    let result = price.divide(0.0);
    assert!(result.is_err());
}

#[test]
fn test_price_from_str_valid() {
    let price = Price::from_str("123.45").expect("Parse valid string");
    assert!((price.to_f64() - 123.45).abs() < 1e-6);
}

#[test]
fn test_price_from_str_invalid() {
    let result = Price::from_str("not_a_number");
    assert!(result.is_err());
}

#[test]
fn test_price_comparison_eq() {
    let p1 = Price::from_f64(100.0).unwrap();
    let p2 = Price::from_f64(100.0).unwrap();
    assert_eq!(p1, p2);
}

#[test]
fn test_price_comparison_with_f64() {
    let price = Price::from_f64(100.0).unwrap();
    assert!(price == 100.0);
    assert!(100.0 == price);
}

#[test]
fn test_price_comparison_ord() {
    let p1 = Price::from_f64(50.0).unwrap();
    let p2 = Price::from_f64(100.0).unwrap();
    assert!(p1 < p2);
    assert!(p2 > p1);
    assert!(p1 <= p2);
    assert!(p2 >= p1);
}

// =============================================================================
// Quantity Type Conversions & Edge Cases
// =============================================================================

#[test]
fn test_quantity_from_f64_valid() {
    let qty = Quantity::from_f64(100.50).expect("Valid quantity");
    assert!((qty.to_f64() - 100.50).abs() < 1e-6);
}

#[test]
fn test_quantity_from_f64_zero() {
    let qty = Quantity::from_f64(0.0).expect("Zero quantity");
    assert_eq!(qty, Quantity::ZERO);
    assert_eq!(qty.to_f64(), 0.0);
}

#[test]
fn test_quantity_from_f64_negative() {
    let result = Quantity::from_f64(-10.5);
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::InvalidQuantity { .. }) => (),
        _ => panic!("Expected InvalidQuantity error for negative value"),
    }
}

#[test]
fn test_quantity_from_f64_nan() {
    let result = Quantity::from_f64(f64::NAN);
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::InvalidQuantity { .. }) => (),
        _ => panic!("Expected InvalidQuantity error for NaN"),
    }
}

#[test]
fn test_quantity_from_f64_infinity() {
    let result = Quantity::from_f64(f64::INFINITY);
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::InvalidQuantity { .. }) => (),
        _ => panic!("Expected InvalidQuantity error for Infinity"),
    }
}

#[test]
fn test_quantity_constants() {
    assert_eq!(Quantity::ZERO.to_f64(), 0.0);
    assert_eq!(Quantity::ONE.to_f64(), 1.0);
    // MAX is u64::MAX in internal representation
    let max_val = Quantity::MAX.to_f64();
    assert!(max_val > 1e8); // At least 100 million
    assert!(max_val.is_finite()); // Should be finite
}

#[test]
fn test_quantity_raw_value_roundtrip() {
    let original = 12345678u64;
    let qty = Quantity::from_raw(original);
    assert_eq!(qty.raw_value(), original);
    assert_eq!(qty.value(), original);
    assert_eq!(qty.as_u64(), original);
}

#[test]
fn test_quantity_to_decimal() {
    let qty = Quantity::from_f64(123.456).unwrap();
    let decimal = qty.to_decimal().expect("Convert to decimal");
    let as_f64: f64 = decimal.to_string().parse().unwrap();
    assert!((as_f64 - 123.456).abs() < 1e-6);
}

#[test]
fn test_quantity_arithmetic_add() {
    let q1 = Quantity::from_f64(100.0).unwrap();
    let q2 = Quantity::from_f64(50.0).unwrap();
    let sum = q1 + q2;
    assert!((sum.to_f64() - 150.0).abs() < 1e-6);
}

#[test]
fn test_quantity_arithmetic_sub() {
    let q1 = Quantity::from_f64(100.0).unwrap();
    let q2 = Quantity::from_f64(30.0).unwrap();
    let diff = q1 - q2;
    assert!((diff.to_f64() - 70.0).abs() < 1e-6);
}

#[test]
fn test_quantity_arithmetic_sub_underflow() {
    let q1 = Quantity::from_f64(10.0).unwrap();
    let q2 = Quantity::from_f64(30.0).unwrap();
    let diff = q1 - q2; // Should saturate to zero
    assert_eq!(diff, Quantity::ZERO);
}

#[test]
fn test_quantity_is_zero() {
    assert!(Quantity::ZERO.is_zero());
    assert!(!Quantity::ONE.is_zero());

    let qty = Quantity::from_f64(0.0).unwrap();
    assert!(qty.is_zero());
}

#[test]
fn test_quantity_multiply_with_quantity() {
    let qty1 = Quantity::from_f64(10.0).unwrap();
    let qty2 = Quantity::from_f64(2.5).unwrap();
    let result = qty1.multiply(qty2).expect("Multiplication");
    // 10 * 2.5 = 25.0
    assert!((result.to_f64() - 25.0).abs() < 1e-4);
}

#[test]
fn test_quantity_decimal_conversion() {
    // Test converting quantity to decimal and back
    let qty = Quantity::from_f64(5.0).unwrap();
    let decimal = qty.to_decimal().expect("Convert to decimal");
    let decimal_val: f64 = decimal.to_string().parse().unwrap();
    assert!((decimal_val - 5.0).abs() < 1e-4);
}

#[test]
fn test_quantity_from_decimal() {
    let decimal = Decimal::from_str("123.456").unwrap();
    let qty = Quantity::from_decimal(decimal).expect("Convert from decimal");
    assert!((qty.to_f64() - 123.456).abs() < 1e-6);
}

#[test]
fn test_quantity_comparison() {
    let q1 = Quantity::from_f64(50.0).unwrap();
    let q2 = Quantity::from_f64(100.0).unwrap();
    assert!(q1 < q2);
    assert!(q2 > q1);
    assert_eq!(q1, q1);
}

// =============================================================================
// Trading Quantity Edge Cases
// =============================================================================

#[test]
fn test_trading_quantity_new_valid() {
    let qty = TradingQuantity::new(100.5).expect("Valid quantity");
    assert!((qty.to_f64() - 100.5).abs() < 1e-6);
}

#[test]
fn test_trading_quantity_negative() {
    let result = TradingQuantity::new(-5.0);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Quantity cannot be negative");
}

#[test]
fn test_trading_quantity_nan() {
    let result = TradingQuantity::new(f64::NAN);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Quantity must be finite");
}

#[test]
fn test_trading_quantity_infinity() {
    let result = TradingQuantity::new(f64::INFINITY);
    assert!(result.is_err());
    assert_eq!(result.unwrap_err(), "Quantity must be finite");
}

#[test]
fn test_trading_quantity_arithmetic() {
    let q1 = TradingQuantity::new(100.0).unwrap();
    let q2 = TradingQuantity::new(50.0).unwrap();

    let sum = q1.add(q2);
    assert!((sum.to_f64() - 150.0).abs() < 1e-6);

    let diff = q1.subtract(q2);
    assert!((diff.to_f64() - 50.0).abs() < 1e-6);
}

#[test]
fn test_trading_quantity_operator_overload() {
    let q1 = TradingQuantity::new(100.0).unwrap();
    let q2 = TradingQuantity::new(30.0).unwrap();

    let sum = q1 + q2;
    assert!((sum.to_f64() - 130.0).abs() < 1e-6);

    let diff = q1 - q2;
    assert!((diff.to_f64() - 70.0).abs() < 1e-6);
}

#[test]
fn test_trading_quantity_to_decimal() {
    let qty = TradingQuantity::new(123.456).unwrap();
    let decimal = qty.to_decimal();
    let as_str = decimal.to_string();
    assert!(as_str.starts_with("123.45"));
}

#[test]
fn test_trading_quantity_display() {
    let qty = TradingQuantity::new(123.456789).unwrap();
    let display = format!("{}", qty);
    assert!(display.starts_with("123.4567"));
}

// =============================================================================
// Display Implementations for Enums
// =============================================================================

#[test]
fn test_order_type_display() {
    assert_eq!(format!("{}", OrderType::Market), "MARKET");
    assert_eq!(format!("{}", OrderType::Limit), "LIMIT");
    assert_eq!(format!("{}", OrderType::Stop), "STOP");
    assert_eq!(format!("{}", OrderType::StopLimit), "STOP_LIMIT");
}

#[test]
fn test_order_side_display() {
    assert_eq!(format!("{}", OrderSide::Buy), "BUY");
    assert_eq!(format!("{}", OrderSide::Sell), "SELL");
}

#[test]
fn test_tick_type_display() {
    assert_eq!(format!("{}", TickType::Trade), "TRADE");
    assert_eq!(format!("{}", TickType::Bid), "BID");
    assert_eq!(format!("{}", TickType::Ask), "ASK");
    assert_eq!(format!("{}", TickType::Quote), "QUOTE");
}

#[test]
fn test_book_action_display() {
    assert_eq!(format!("{}", BookAction::Update), "UPDATE");
    assert_eq!(format!("{}", BookAction::Delete), "DELETE");
    assert_eq!(format!("{}", BookAction::Clear), "CLEAR");
}

#[test]
fn test_market_regime_display() {
    assert_eq!(format!("{}", MarketRegime::Normal), "NORMAL");
    assert_eq!(format!("{}", MarketRegime::Crisis), "CRISIS");
    assert_eq!(format!("{}", MarketRegime::Trending), "TRENDING");
    assert_eq!(format!("{}", MarketRegime::Sideways), "SIDEWAYS");
    assert_eq!(format!("{}", MarketRegime::Bull), "BULL");
    assert_eq!(format!("{}", MarketRegime::Bear), "BEAR");
}

#[test]
fn test_order_event_type_display() {
    assert_eq!(format!("{}", OrderEventType::Placed), "PLACED");
    assert_eq!(format!("{}", OrderEventType::Modified), "MODIFIED");
    assert_eq!(format!("{}", OrderEventType::Cancelled), "CANCELLED");
    assert_eq!(format!("{}", OrderEventType::Rejected), "REJECTED");
    assert_eq!(format!("{}", OrderEventType::Expired), "EXPIRED");
}

#[test]
fn test_types_order_type_display() {
    assert_eq!(format!("{}", TypesOrderType::Market), "MARKET");
    assert_eq!(format!("{}", TypesOrderType::Limit), "LIMIT");
    assert_eq!(format!("{}", TypesOrderType::Stop), "STOP");
    assert_eq!(format!("{}", TypesOrderType::StopLimit), "STOP_LIMIT");
}

#[test]
fn test_types_order_side_display() {
    assert_eq!(format!("{}", TypesOrderSide::Buy), "BUY");
    assert_eq!(format!("{}", TypesOrderSide::Sell), "SELL");
}

#[test]
fn test_time_in_force_display() {
    assert_eq!(format!("{}", TimeInForce::Day), "DAY");
    assert_eq!(format!("{}", TimeInForce::GoodTillCancel), "GTC");
    assert_eq!(format!("{}", TimeInForce::ImmediateOrCancel), "IOC");
    assert_eq!(format!("{}", TimeInForce::FillOrKill), "FOK");
}

#[test]
fn test_currency_display() {
    assert_eq!(format!("{}", Currency::USD), "USD");
    assert_eq!(format!("{}", Currency::EUR), "EUR");
    assert_eq!(format!("{}", Currency::GBP), "GBP");
    assert_eq!(format!("{}", Currency::JPY), "JPY");
    assert_eq!(format!("{}", Currency::BTC), "BTC");
    assert_eq!(format!("{}", Currency::ETH), "ETH");
}

#[test]
fn test_order_status_display() {
    assert_eq!(format!("{}", OrderStatus::Created), "CREATED");
    assert_eq!(format!("{}", OrderStatus::Pending), "PENDING");
    assert_eq!(
        format!("{}", OrderStatus::PartiallyFilled),
        "PARTIALLY_FILLED"
    );
    assert_eq!(format!("{}", OrderStatus::Filled), "FILLED");
    assert_eq!(format!("{}", OrderStatus::Cancelled), "CANCELLED");
    assert_eq!(format!("{}", OrderStatus::Rejected), "REJECTED");
    assert_eq!(format!("{}", OrderStatus::Expired), "EXPIRED");
}

// =============================================================================
// ID Type Validation
// =============================================================================

#[test]
fn test_event_id_new() {
    let id1 = EventId::new();
    let id2 = EventId::new();
    assert_ne!(id1, id2); // Each should be unique
}

#[test]
fn test_event_id_from_string_valid() {
    let id = EventId::from_string("test-event-123");
    assert_eq!(id.to_string(), "test-event-123");
}

#[test]
fn test_event_id_from_string_empty() {
    let id = EventId::from_string("");
    // Should generate new UUID for empty string
    assert!(!id.to_string().is_empty());
}

#[test]
fn test_event_id_display() {
    let id = EventId::from_string("display-test");
    assert_eq!(format!("{}", id), "display-test");
}

#[test]
fn test_fill_id_new_valid() {
    let result = FillId::new("fill-12345");
    assert!(result.is_ok());
    let fill_id = result.unwrap();
    assert_eq!(fill_id.to_string(), "fill-12345");
}

#[test]
fn test_fill_id_new_empty() {
    let result = FillId::new("");
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::ValidationError { field, reason }) => {
            assert_eq!(field, "fill_id");
            assert!(reason.contains("empty"));
        },
        _ => panic!("Expected ValidationError for empty fill_id"),
    }
}

#[test]
fn test_fill_id_display() {
    let fill_id = FillId::new("fill-display").unwrap();
    assert_eq!(format!("{}", fill_id), "fill-display");
}

#[test]
fn test_aggregate_id_new_valid() {
    let result = AggregateId::new("aggregate-789");
    assert!(result.is_ok());
    let agg_id = result.unwrap();
    assert_eq!(agg_id.to_string(), "aggregate-789");
}

#[test]
fn test_aggregate_id_new_empty() {
    let result = AggregateId::new("");
    assert!(result.is_err());
    match result {
        Err(CommonTypeError::ValidationError { field, reason }) => {
            assert_eq!(field, "aggregate_id");
            assert!(reason.contains("empty"));
        },
        _ => panic!("Expected ValidationError for empty aggregate_id"),
    }
}

// =============================================================================
// DecimalExt Trait
// =============================================================================

#[test]
fn test_decimal_ext_from_f64_valid() {
    let decimal = Decimal::from_f64(123.456).expect("Valid conversion");
    let as_str = decimal.to_string();
    assert!(as_str.starts_with("123.45"));
}

#[test]
fn test_decimal_ext_from_f64_zero() {
    let decimal = Decimal::from_f64(0.0).expect("Zero");
    assert_eq!(decimal, Decimal::ZERO);
}

#[test]
fn test_decimal_ext_from_f64_nan() {
    let result = Decimal::from_f64(f64::NAN);
    assert!(result.is_none());
}

#[test]
fn test_decimal_ext_from_f64_infinity() {
    let result = Decimal::from_f64(f64::INFINITY);
    assert!(result.is_none());
}

#[test]
fn test_decimal_ext_sqrt_positive() {
    let decimal = Decimal::from_str("16.0").unwrap();
    let sqrt = decimal.sqrt().expect("Valid sqrt");
    let as_f64: f64 = sqrt.to_string().parse().unwrap();
    assert!((as_f64 - 4.0).abs() < 1e-6);
}

#[test]
fn test_decimal_ext_sqrt_zero() {
    let decimal = Decimal::ZERO;
    let sqrt = decimal.sqrt().expect("Sqrt of zero");
    assert_eq!(sqrt, Decimal::ZERO);
}

#[test]
fn test_decimal_ext_sqrt_negative() {
    let decimal = Decimal::from_str("-16.0").unwrap();
    let result = decimal.sqrt();
    assert!(result.is_none()); // No sqrt for negative numbers
}

#[test]
fn test_decimal_ext_sqrt_precision() {
    let decimal = Decimal::from_str("2.0").unwrap();
    let sqrt = decimal.sqrt().expect("Sqrt of 2");
    let as_f64: f64 = sqrt.to_string().parse().unwrap();
    // sqrt(2) ≈ 1.41421356
    #[allow(clippy::approx_constant)]
    let sqrt_2 = 1.41421356;
    assert!((as_f64 - sqrt_2).abs() < 1e-6);
}

// =============================================================================
// Threshold Constants Validation
// =============================================================================

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_risk_breach_thresholds_ordered() {
    assert!(thresholds::risk::BREACH_WARNING_PCT < thresholds::risk::BREACH_SOFT_PCT);
    assert!(thresholds::risk::BREACH_SOFT_PCT < thresholds::risk::BREACH_HARD_PCT);
    assert!(thresholds::risk::BREACH_HARD_PCT < thresholds::risk::BREACH_CRITICAL_PCT);
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_var_z_scores_ordered() {
    assert!(thresholds::var::Z_SCORE_P90 < thresholds::var::Z_SCORE_P95);
    assert!(thresholds::var::Z_SCORE_P95 < thresholds::var::Z_SCORE_P97_5);
    assert!(thresholds::var::Z_SCORE_P97_5 < thresholds::var::Z_SCORE_P99);
    assert!(thresholds::var::Z_SCORE_P99 < thresholds::var::Z_SCORE_P99_9);
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_var_confidence_levels() {
    assert_eq!(thresholds::risk::DEFAULT_VAR_CONFIDENCE, 0.95);
    assert_eq!(thresholds::risk::HIGH_VAR_CONFIDENCE, 0.99);
    assert!(thresholds::risk::DEFAULT_VAR_CONFIDENCE < thresholds::risk::HIGH_VAR_CONFIDENCE);
}

#[test]
fn test_time_conversion_constants() {
    assert_eq!(thresholds::time::NANOS_PER_MICRO, 1_000);
    assert_eq!(thresholds::time::NANOS_PER_MILLI, 1_000_000);
    assert_eq!(thresholds::time::NANOS_PER_SECOND, 1_000_000_000);
    assert_eq!(thresholds::time::MICROS_PER_SECOND, 1_000_000);
    assert_eq!(thresholds::time::MILLIS_PER_SECOND, 1_000);
}

#[test]
fn test_time_conversion_relationships() {
    assert_eq!(
        thresholds::time::NANOS_PER_MICRO * 1000,
        thresholds::time::NANOS_PER_MILLI
    );
    assert_eq!(
        thresholds::time::NANOS_PER_MILLI * 1000,
        thresholds::time::NANOS_PER_SECOND
    );
    assert_eq!(
        thresholds::time::MICROS_PER_SECOND * 1000,
        thresholds::time::NANOS_PER_SECOND
    );
}

#[test]
fn test_financial_scale_consistency() {
    assert_eq!(
        thresholds::financial::PRICE_SCALE,
        thresholds::financial::UNIFIED_SCALE_FACTOR
    );
    assert_eq!(
        thresholds::financial::QUANTITY_SCALE,
        thresholds::financial::UNIFIED_SCALE_FACTOR
    );
    assert_eq!(
        thresholds::financial::MONEY_SCALE,
        thresholds::financial::UNIFIED_SCALE_FACTOR
    );
    assert_eq!(thresholds::financial::UNIFIED_SCALE_FACTOR, 1_000_000);
}

#[test]
fn test_financial_basis_points() {
    assert_eq!(thresholds::financial::BASIS_POINTS_PER_UNIT, 10_000);
    assert_eq!(thresholds::financial::CENTS_PER_DOLLAR, 100);
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_limits_price_quantity_ranges() {
    assert!(thresholds::limits::MIN_PRICE > 0.0);
    assert!(thresholds::limits::MAX_PRICE > thresholds::limits::MIN_PRICE);
    assert!(thresholds::limits::MIN_QUANTITY > 0.0);
    assert!(thresholds::limits::MAX_QUANTITY > thresholds::limits::MIN_QUANTITY);
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_limits_string_lengths() {
    assert!(thresholds::limits::MAX_SYMBOL_LENGTH > 0);
    assert!(thresholds::limits::MAX_ACCOUNT_ID_LENGTH > 0);
    assert!(thresholds::limits::MAX_DESCRIPTION_LENGTH > 0);
    assert!(
        thresholds::limits::MAX_METADATA_KEY_LENGTH < thresholds::limits::MAX_METADATA_VALUE_LENGTH
    );
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_performance_batch_sizes() {
    assert!(thresholds::performance::DEFAULT_BATCH_SIZE > 0);
    assert!(thresholds::performance::SIMD_BATCH_SIZE > 0);
    assert!(
        thresholds::performance::MAX_SMALL_BATCH_SIZE >= thresholds::performance::SIMD_BATCH_SIZE
    );
    assert!(
        thresholds::performance::RING_BUFFER_SIZE > thresholds::performance::DEFAULT_BATCH_SIZE
    );
}

#[test]
fn test_hardware_alignment_constants() {
    assert_eq!(thresholds::hardware::CACHE_LINE_SIZE, 64);
    assert_eq!(thresholds::hardware::SIMD_ALIGNMENT, 32);
    assert_eq!(thresholds::hardware::PAGE_SIZE, 4096);
    // Page size should be multiple of cache line size
    assert_eq!(
        thresholds::hardware::PAGE_SIZE % thresholds::hardware::CACHE_LINE_SIZE,
        0
    );
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_constants_pool_sizes() {
    assert!(DEFAULT_POOL_SIZE > 0);
    assert!(MAX_POOL_SIZE > DEFAULT_POOL_SIZE);
    assert!(MAX_POOL_SIZE >= 100);
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_constants_timeouts() {
    assert!(MAX_QUERY_TIMEOUT_MS > 0);
    assert!(DEFAULT_HEALTH_CHECK_INTERVAL_SECONDS > 0);
    assert!(DEFAULT_SERVICE_TIMEOUT_SECONDS > 0);
    assert!(CONFIG_REFRESH_INTERVAL_SECONDS > 0);
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_constants_latency_thresholds() {
    assert_eq!(MAX_HFT_LATENCY_MICROS, 50);
    assert!(MAX_HFT_LATENCY_MICROS > 0);
}

#[test]
#[allow(clippy::assertions_on_constants)]
fn test_constants_port_ranges() {
    assert!(DEFAULT_GRPC_PORT_START >= 50000);
    assert!(DEFAULT_HTTP_PORT_START >= 8000);
}

// =============================================================================
// Edge Case Combinations
// =============================================================================

#[test]
fn test_price_quantity_multiplication_edge_cases() {
    // Zero quantity multiplication
    let qty_zero = Quantity::ZERO;
    let qty_nonzero = Quantity::from_f64(100.0).unwrap();
    let result = qty_zero.multiply(qty_nonzero).unwrap();
    assert_eq!(result, Quantity::ZERO);

    // Zero price multiplication
    let price_zero = Price::ZERO;
    let price_nonzero = Price::from_f64(10.0).unwrap();
    let result = price_zero.multiply(price_nonzero).unwrap();
    assert_eq!(result, Price::ZERO);
}

#[test]
fn test_conversion_roundtrip_price() {
    let original = 123.456789;
    let price = Price::from_f64(original).unwrap();
    let decimal = price.to_decimal().unwrap();
    let price2 = Price::from_decimal(decimal);

    // Should be approximately equal (within precision limits)
    assert!((price.to_f64() - price2.to_f64()).abs() < 1e-6);
}

#[test]
fn test_conversion_roundtrip_quantity() {
    let original = 987.654321;
    let qty = Quantity::from_f64(original).unwrap();
    let decimal = qty.to_decimal().unwrap();
    let qty2 = Quantity::from_decimal(decimal).unwrap();

    // Should be approximately equal (within precision limits)
    assert!((qty.to_f64() - qty2.to_f64()).abs() < 1e-6);
}

#[test]
fn test_boundary_values_u64_max() {
    // Test near u64::MAX boundaries - internal representation is u64::MAX
    let max_qty = Quantity::MAX;
    let qty_val = max_qty.to_f64();
    assert!(qty_val > 1e8); // At least 100 million
    assert!(qty_val.is_finite());

    let max_price = Price::MAX;
    let price_val = max_price.to_f64();
    assert!(price_val > 1e8); // At least 100 million
    assert!(price_val.is_finite());
}

#[test]
fn test_very_small_values_precision() {
    // Test precision at very small values
    let small = 0.00000001; // 1e-8
    let price = Price::from_f64(small).unwrap();
    let recovered = price.to_f64();
    assert!((recovered - small).abs() < 1e-9);
}

#[test]
fn test_saturating_arithmetic_overflow() {
    // Test that arithmetic saturates instead of panicking
    let max_qty = Quantity::MAX;
    let one = Quantity::ONE;

    let sum = max_qty + one; // Should saturate
    assert_eq!(sum, Quantity::MAX); // Saturating add
}

#[test]
fn test_multiple_operations_accumulation() {
    // Test accumulation of rounding errors
    let mut price = Price::from_f64(1.0).unwrap();

    for _ in 0..1000 {
        price = (price + Price::from_f64(0.001).unwrap()) - Price::from_f64(0.001).unwrap();
    }

    // Should remain close to 1.0 despite many operations
    assert!((price.to_f64() - 1.0).abs() < 0.01);
}
