rusty_backtest/features/

tardis_features.rs

//! Advanced Microstructural Features from Binance Tardis L2 Structure
//!
//! This module implements comprehensive microstructural features based on
//! the Binance Tardis L2 data structure, including:
//! - Weighted Order Imbalance
//! - Relative Spread
//! - Volume-Weighted OFI
//! - Depth-Weighted OFI
//! - Queue Imbalance with multi-level support
//! - Liquidity Shocks
//! - Price Run
//! - Advanced VPIN calculations

use super::{Level, OrderBookSnapshot, TradeSide, TradeTick, decimal_to_f64_or_nan};
use rust_decimal::Decimal;
use rust_decimal_macros::dec;
use smallvec::SmallVec;
use std::collections::VecDeque;

/// Weighted Order Imbalance
///
/// Calculates imbalance using weighted volumes where closer levels have higher weights
#[inline(always)]
pub fn calculate_weighted_order_imbalance(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
    depth: usize,
) -> f64 {
    let depth = depth.min(bids.len()).min(asks.len());
    if depth == 0 {
        return f64::NAN;
    }

    let mut bid_qty_sum = Decimal::ZERO;
    let mut ask_qty_sum = Decimal::ZERO;
    let mut bid_weighted = Decimal::ZERO;
    let mut ask_weighted = Decimal::ZERO;

    for i in 0..depth {
        let weight = Decimal::from((depth - i) as u64);

        if i < bids.len() {
            bid_qty_sum += bids[i].quantity;
            bid_weighted += bids[i].quantity * weight;
        }

        if i < asks.len() {
            ask_qty_sum += asks[i].quantity;
            ask_weighted += asks[i].quantity * weight;
        }
    }

    let total_sum = bid_qty_sum + ask_qty_sum;
    if total_sum == Decimal::ZERO {
        return 0.0;
    }

    decimal_to_f64_or_nan((bid_weighted - ask_weighted) / total_sum)
}

/// Relative Spread
///
/// Spread normalized by mid price
#[inline(always)]
pub fn calculate_relative_spread(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
) -> f64 {
    if bids.is_empty() || asks.is_empty() {
        return f64::NAN;
    }

    let best_bid = bids[0].price;
    let best_ask = asks[0].price;
    let mid_price = (best_bid + best_ask) / dec!(2);

    if mid_price == Decimal::ZERO {
        return f64::NAN;
    }

    decimal_to_f64_or_nan((best_ask - best_bid) / mid_price)
}

/// Volume-Weighted OFI
///
/// Calculates order flow imbalance using volume-weighted average prices
pub fn calculate_volume_weighted_ofi(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
    depth: usize,
) -> f64 {
    let depth = depth.min(bids.len()).min(asks.len());
    if depth == 0 {
        return f64::NAN;
    }

    let mut bid_vwap = Decimal::ZERO;
    let mut ask_vwap = Decimal::ZERO;
    let mut bid_qty_sum = Decimal::ZERO;
    let mut ask_qty_sum = Decimal::ZERO;

    // Calculate bid VWAP
    for i in 0..depth.min(bids.len()) {
        bid_qty_sum += bids[i].quantity;
    }

    if bid_qty_sum > Decimal::ZERO {
        for i in 0..depth.min(bids.len()) {
            bid_vwap += bids[i].price * bids[i].quantity / bid_qty_sum;
        }
    }

    // Calculate ask VWAP
    for i in 0..depth.min(asks.len()) {
        ask_qty_sum += asks[i].quantity;
    }

    if ask_qty_sum > Decimal::ZERO {
        for i in 0..depth.min(asks.len()) {
            ask_vwap += asks[i].price * asks[i].quantity / ask_qty_sum;
        }
    }

    decimal_to_f64_or_nan(bid_vwap - ask_vwap)
}

/// Depth-Weighted OFI
///
/// Order flow imbalance weighted by level depth
#[inline(always)]
pub fn calculate_depth_weighted_ofi(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
    depth: usize,
) -> f64 {
    let depth = depth.min(bids.len()).min(asks.len());
    if depth == 0 {
        return f64::NAN;
    }

    let mut bid_depth_weighted = Decimal::ZERO;
    let mut ask_depth_weighted = Decimal::ZERO;

    for i in 0..depth {
        let weight = Decimal::from((depth - i) as u64);

        if i < bids.len() {
            bid_depth_weighted += bids[i].price * weight;
        }

        if i < asks.len() {
            ask_depth_weighted += asks[i].price * weight;
        }
    }

    decimal_to_f64_or_nan(bid_depth_weighted - ask_depth_weighted)
}

/// Liquidity Shocks Detector
///
/// Detects abrupt changes in liquidity by comparing top levels to total depth
#[inline(always)]
pub fn calculate_liquidity_shock_ratio(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
    top_levels: usize,
) -> f64 {
    if bids.is_empty() && asks.is_empty() {
        return f64::NAN;
    }

    let mut total_qty = Decimal::ZERO;
    let mut top_qty = Decimal::ZERO;

    // Sum all quantities
    for bid in bids {
        total_qty += bid.quantity;
    }
    for ask in asks {
        total_qty += ask.quantity;
    }

    // Sum top level quantities
    for i in 0..top_levels.min(bids.len()) {
        top_qty += bids[i].quantity;
    }
    for i in 0..top_levels.min(asks.len()) {
        top_qty += asks[i].quantity;
    }

    if total_qty == Decimal::ZERO {
        return f64::NAN;
    }

    decimal_to_f64_or_nan(top_qty / total_qty)
}

/// Price Run Calculator
///
/// Calculates the proportion of successive price increases over a window
pub struct PriceRunCalculator {
    price_changes: VecDeque<bool>, // true for increase, false for decrease
    window_size: usize,
    last_mid_price: Option<Decimal>,
}

impl PriceRunCalculator {
    /// Create a new price run calculator with specified window size
    #[must_use]
    pub fn new(window_size: usize) -> Self {
        Self {
            price_changes: VecDeque::with_capacity(window_size),
            window_size,
            last_mid_price: None,
        }
    }

    /// Update with new orderbook snapshot and return the price run ratio
    #[must_use]
    pub fn update(&mut self, snapshot: &OrderBookSnapshot) -> f64 {
        let mid_price = snapshot.mid_price();

        if let Some(last_price) = self.last_mid_price {
            if mid_price > last_price {
                self.price_changes.push_back(true);
            } else if mid_price < last_price {
                self.price_changes.push_back(false);
            }
            // Equal prices don't count as changes

            if self.price_changes.len() > self.window_size {
                self.price_changes.pop_front();
            }
        }

        self.last_mid_price = Some(mid_price);

        if self.price_changes.is_empty() {
            return f64::NAN;
        }

        let increases = self.price_changes.iter().filter(|&&x| x).count();
        increases as f64 / self.price_changes.len() as f64
    }
}

/// Advanced VPIN Calculator with Volume Buckets
///
/// Implements Volume-Synchronized Probability of Informed Trading
/// with proper volume bucketing
pub struct AdvancedVPINCalculator {
    bucket_size: Decimal,
    buckets: VecDeque<VolumeBucket>,
    current_bucket: VolumeBucket,
    window_size: usize,
}

#[derive(Debug, Clone)]
struct VolumeBucket {
    buy_volume: Decimal,
    sell_volume: Decimal,
    total_volume: Decimal,
}

impl VolumeBucket {
    const fn new() -> Self {
        Self {
            buy_volume: Decimal::ZERO,
            sell_volume: Decimal::ZERO,
            total_volume: Decimal::ZERO,
        }
    }

    fn add_trade(&mut self, side: TradeSide, quantity: Decimal) {
        match side {
            TradeSide::Buy => self.buy_volume += quantity,
            TradeSide::Sell => self.sell_volume += quantity,
        }
        self.total_volume += quantity;
    }

    fn is_full(&self, bucket_size: Decimal) -> bool {
        self.total_volume >= bucket_size
    }

    fn vpin(&self) -> f64 {
        if self.total_volume == Decimal::ZERO {
            return 0.0;
        }

        let buy_ratio = decimal_to_f64_or_nan(self.buy_volume / self.total_volume);
        let sell_ratio = decimal_to_f64_or_nan(self.sell_volume / self.total_volume);

        (buy_ratio - sell_ratio).abs()
    }
}

impl AdvancedVPINCalculator {
    /// Create a new advanced VPIN calculator with specified bucket size and window
    #[must_use]
    pub fn new(bucket_size: Decimal, window_size: usize) -> Self {
        Self {
            bucket_size,
            buckets: VecDeque::with_capacity(window_size),
            current_bucket: VolumeBucket::new(),
            window_size,
        }
    }

    /// Add a trade to the VPIN calculation
    pub fn add_trade(&mut self, trade: &TradeTick) {
        let mut remaining_qty = trade.quantity;

        while remaining_qty > Decimal::ZERO {
            let space_in_bucket = self.bucket_size - self.current_bucket.total_volume;
            let qty_to_add = remaining_qty.min(space_in_bucket);

            self.current_bucket.add_trade(trade.side, qty_to_add);
            remaining_qty -= qty_to_add;

            if self.current_bucket.is_full(self.bucket_size) {
                // Complete the bucket
                self.buckets.push_back(self.current_bucket.clone());

                if self.buckets.len() > self.window_size {
                    self.buckets.pop_front();
                }

                self.current_bucket = VolumeBucket::new();
            }
        }
    }

    /// Calculate the average VPIN across all buckets
    #[must_use]
    pub fn calculate(&self) -> f64 {
        if self.buckets.is_empty() {
            return 0.0;
        }

        let sum_vpin: f64 = self.buckets.iter().map(|bucket| bucket.vpin()).sum();

        sum_vpin / self.buckets.len() as f64
    }
}

/// Order Cancel Estimated Rate
///
/// Estimates the rate of order cancellations based on ask/bid imbalance
#[inline(always)]
pub fn calculate_order_cancel_rate(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
) -> f64 {
    let mut ask_sum = Decimal::ZERO;
    let mut bid_sum = Decimal::ZERO;

    for ask in asks {
        ask_sum += ask.quantity;
    }

    for bid in bids {
        bid_sum += bid.quantity;
    }

    let total_sum = ask_sum + bid_sum;
    if total_sum == Decimal::ZERO {
        return f64::NAN;
    }

    decimal_to_f64_or_nan(ask_sum / total_sum)
}

/// Relative Tick Volume Calculator
///
/// Normalizes volume relative to recent average
pub struct RelativeTickVolumeCalculator {
    volumes: VecDeque<Decimal>,
    window_size: usize,
}

impl RelativeTickVolumeCalculator {
    /// Create a new relative tick volume calculator
    #[must_use]
    pub fn new(window_size: usize) -> Self {
        Self {
            volumes: VecDeque::with_capacity(window_size),
            window_size,
        }
    }

    /// Add a trade and return the relative volume compared to recent average
    #[must_use]
    pub fn add_trade(&mut self, trade: &TradeTick) -> f64 {
        self.volumes.push_back(trade.quantity);

        if self.volumes.len() > self.window_size {
            self.volumes.pop_front();
        }

        if self.volumes.is_empty() {
            return 1.0;
        }

        let sum: Decimal = self.volumes.iter().sum();
        let avg = sum / Decimal::from(self.volumes.len() as u64);

        if avg == Decimal::ZERO {
            return f64::NAN;
        }

        decimal_to_f64_or_nan(trade.quantity / avg)
    }
}

/// Order Book Depth Calculator
///
/// Calculates total depth (sum of all bid and ask quantities)
#[inline(always)]
pub fn calculate_order_book_depth(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
) -> Decimal {
    let mut total = Decimal::ZERO;

    for bid in bids {
        total += bid.quantity;
    }

    for ask in asks {
        total += ask.quantity;
    }

    total
}

/// Order Book Slope Calculator
///
/// Measures the ratio of total ask to bid quantities
#[inline(always)]
pub fn calculate_order_book_slope(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
) -> f64 {
    let mut ask_sum = Decimal::ZERO;
    let mut bid_sum = Decimal::ZERO;

    for ask in asks {
        ask_sum += ask.quantity;
    }

    for bid in bids {
        bid_sum += bid.quantity;
    }

    if bid_sum == Decimal::ZERO {
        return f64::NAN;
    }

    decimal_to_f64_or_nan(ask_sum / bid_sum)
}

/// Exponential Decay Rate Calculator
///
/// Computes exponential weighted moving statistics for price movements
pub struct ExponentialDecayCalculator {
    alpha: f64,
    ewm_mean: f64,
    ewm_var: f64,
    ewm_std: f64,
    count: usize,
    last_value: Option<f64>,
}

impl ExponentialDecayCalculator {
    /// Create a new exponential decay calculator with the given span
    #[must_use]
    pub fn new(span: usize) -> Self {
        let alpha = 2.0 / (span as f64 + 1.0);
        Self {
            alpha,
            ewm_mean: 0.0,
            ewm_var: 0.0,
            ewm_std: 0.0,
            count: 0,
            last_value: None,
        }
    }

    /// Update the calculator with a new value
    pub fn update(&mut self, value: f64) {
        if self.count == 0 {
            self.ewm_mean = value;
            self.ewm_var = 0.0;
            self.ewm_std = 0.0;
        } else {
            let delta = value - self.ewm_mean;
            self.ewm_mean += self.alpha * delta;
            self.ewm_var = (1.0 - self.alpha) * (self.ewm_var + self.alpha * delta * delta);
            self.ewm_std = self.ewm_var.sqrt();
        }

        self.count += 1;
        self.last_value = Some(value);
    }
    /// Get the current exponentially weighted mean
    pub const fn get_mean(&self) -> f64 {
        self.ewm_mean
    }
    /// Get the current exponentially weighted standard deviation
    pub const fn get_std(&self) -> f64 {
        self.ewm_std
    }
    /// Get the current exponentially weighted variance
    pub const fn get_var(&self) -> f64 {
        self.ewm_var
    }
}

/// Rolling Price Impact Calculator
///
/// Measures how volume moves price over a rolling window
pub struct RollingPriceImpactCalculator {
    price_window: VecDeque<Decimal>,
    volume_window: VecDeque<Decimal>,
    window_size: usize,
}

impl RollingPriceImpactCalculator {
    /// Create a new rolling price impact calculator
    #[must_use]
    pub fn new(window_size: usize) -> Self {
        Self {
            price_window: VecDeque::with_capacity(window_size),
            volume_window: VecDeque::with_capacity(window_size),
            window_size,
        }
    }

    /// Add a trade and calculate Kyle's lambda (price impact coefficient)
    #[must_use]
    pub fn add_trade(&mut self, trade: &TradeTick) -> f64 {
        self.price_window.push_back(trade.price);
        self.volume_window.push_back(trade.quantity);

        if self.price_window.len() > self.window_size {
            self.price_window.pop_front();
            self.volume_window.pop_front();
        }

        if self.price_window.len() < 2 {
            return f64::NAN;
        }

        // Calculate price standard deviation
        let prices: Vec<f64> = self
            .price_window
            .iter()
            .map(|&p| decimal_to_f64_or_nan(p))
            .collect();
        let mean = prices.iter().sum::<f64>() / prices.len() as f64;
        let variance =
            prices.iter().map(|&p| (p - mean).powi(2)).sum::<f64>() / prices.len() as f64;
        let price_std = variance.sqrt();

        // Calculate total volume
        let total_volume = self.volume_window.iter().sum::<Decimal>();

        if price_std == 0.0 {
            return f64::NAN;
        }

        decimal_to_f64_or_nan(total_volume) / price_std
    }
}

/// Volume-to-Price Sensitivity Calculator
///
/// Measures how volume changes relative to price changes
pub struct VolumePriceSensitivityCalculator {
    price_changes: VecDeque<f64>,
    volume_changes: VecDeque<f64>,
    window_size: usize,
    last_price: Option<Decimal>,
    last_volume: Option<Decimal>,
}

impl VolumePriceSensitivityCalculator {
    /// Create a new volume-price sensitivity calculator
    #[must_use]
    pub fn new(window_size: usize) -> Self {
        Self {
            price_changes: VecDeque::with_capacity(window_size),
            volume_changes: VecDeque::with_capacity(window_size),
            window_size,
            last_price: None,
            last_volume: None,
        }
    }

    /// Add a trade and calculate the volume-price sensitivity ratio
    #[must_use]
    pub fn add_trade(&mut self, trade: &TradeTick) -> f64 {
        if let (Some(last_p), Some(last_v)) = (self.last_price, self.last_volume) {
            let price_change = decimal_to_f64_or_nan((trade.price - last_p).abs());
            let volume_change = decimal_to_f64_or_nan((trade.quantity - last_v).abs());

            self.price_changes.push_back(price_change);
            self.volume_changes.push_back(volume_change);

            if self.price_changes.len() > self.window_size {
                self.price_changes.pop_front();
                self.volume_changes.pop_front();
            }
        }

        self.last_price = Some(trade.price);
        self.last_volume = Some(trade.quantity);

        if self.price_changes.is_empty() {
            return f64::NAN;
        }

        let avg_price_change =
            self.price_changes.iter().sum::<f64>() / self.price_changes.len() as f64;
        let avg_volume_change =
            self.volume_changes.iter().sum::<f64>() / self.volume_changes.len() as f64;

        if avg_price_change == 0.0 {
            return f64::NAN;
        }

        avg_volume_change / avg_price_change
    }
}

/// Entropy of Price Changes Calculator
///
/// Measures the randomness or predictability of price movements
pub struct PriceEntropyCalculator {
    price_changes: VecDeque<i8>, // -1, 0, 1 for down, no change, up
    window_size: usize,
    last_price: Option<Decimal>,
}

impl PriceEntropyCalculator {
    /// Create a new price entropy calculator
    #[must_use]
    pub fn new(window_size: usize) -> Self {
        Self {
            price_changes: VecDeque::with_capacity(window_size),
            window_size,
            last_price: None,
        }
    }

    /// Update with new price and calculate Shannon entropy
    #[must_use]
    pub fn update(&mut self, price: Decimal) -> f64 {
        if let Some(last) = self.last_price {
            let change = if price > last {
                1
            } else if price < last {
                -1
            } else {
                0
            };

            self.price_changes.push_back(change);

            if self.price_changes.len() > self.window_size {
                self.price_changes.pop_front();
            }
        }

        self.last_price = Some(price);

        if self.price_changes.len() < 10 {
            return f64::NAN;
        }

        // Count occurrences
        let mut counts = [0u32; 3]; // for -1, 0, 1
        for &change in &self.price_changes {
            counts[(change + 1) as usize] += 1;
        }

        // Calculate entropy
        let total = self.price_changes.len() as f64;
        let mut entropy = 0.0;

        for &count in &counts {
            if count > 0 {
                let prob = count as f64 / total;
                entropy -= prob * prob.log2();
            }
        }

        entropy
    }
}

/// Multi-Level OFI with Price Matching
///
/// Detailed OFI calculation that tracks volume changes at specific price levels
pub fn calculate_multi_level_ofi_detailed(
    prev_bids: &SmallVec<[Level; 25]>,
    prev_asks: &SmallVec<[Level; 25]>,
    curr_bids: &SmallVec<[Level; 25]>,
    curr_asks: &SmallVec<[Level; 25]>,
) -> f64 {
    let mut ofi = Decimal::ZERO;

    // Process bid side
    for prev_bid in prev_bids {
        // Find matching price in current bids
        let matching_bid = curr_bids.iter().find(|b| b.price == prev_bid.price);

        if let Some(curr_bid) = matching_bid {
            let delta_vol = curr_bid.quantity - prev_bid.quantity;
            ofi += delta_vol * curr_bid.price;
        }
    }

    // Process ask side
    for prev_ask in prev_asks {
        // Find matching price in current asks
        let matching_ask = curr_asks.iter().find(|a| a.price == prev_ask.price);

        if let Some(curr_ask) = matching_ask {
            let delta_vol = curr_ask.quantity - prev_ask.quantity;
            ofi -= delta_vol * curr_ask.price;
        }
    }

    decimal_to_f64_or_nan(ofi)
}

/// Bursts in Trading Activity Calculator
///
/// Detects periods of heightened trading activity using rolling variance
pub struct TradingBurstDetector {
    volumes: VecDeque<Decimal>,
    window_size: usize,
}

impl TradingBurstDetector {
    /// Create a new trading burst detector
    #[must_use]
    pub fn new(window_size: usize) -> Self {
        Self {
            volumes: VecDeque::with_capacity(window_size),
            window_size,
        }
    }

    /// Add a trade and return the relative volume compared to recent average
    #[must_use]
    pub fn add_trade(&mut self, trade: &TradeTick) -> f64 {
        self.volumes.push_back(trade.quantity);

        if self.volumes.len() > self.window_size {
            self.volumes.pop_front();
        }

        if self.volumes.len() < 2 {
            return f64::NAN;
        }

        // Calculate variance
        let volumes_f64: Vec<f64> = self
            .volumes
            .iter()
            .map(|&v| decimal_to_f64_or_nan(v))
            .collect();

        let mean = volumes_f64.iter().sum::<f64>() / volumes_f64.len() as f64;
        let variance =
            volumes_f64.iter().map(|&v| (v - mean).powi(2)).sum::<f64>() / volumes_f64.len() as f64;

        variance.sqrt()
    }
}

/// Queue Imbalance at Multiple Levels
///
/// Calculates normalized difference between top bid and ask queues
#[inline(always)]
pub fn calculate_multi_level_queue_imbalance(
    bids: &SmallVec<[Level; 25]>,
    asks: &SmallVec<[Level; 25]>,
    levels: usize,
) -> f64 {
    let mut ask_sum = Decimal::ZERO;
    let mut bid_sum = Decimal::ZERO;

    for i in 0..levels.min(asks.len()) {
        ask_sum += asks[i].quantity;
    }

    for i in 0..levels.min(bids.len()) {
        bid_sum += bids[i].quantity;
    }

    let total = ask_sum + bid_sum;
    if total == Decimal::ZERO {
        return f64::NAN;
    }

    decimal_to_f64_or_nan((ask_sum - bid_sum) / total)
}

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

    fn create_test_levels(prices: &[f64], quantities: &[f64]) -> SmallVec<[Level; 25]> {
        prices
            .iter()
            .zip(quantities.iter())
            .map(|(&p, &q)| Level {
                price: Decimal::from_f64_retain(p).unwrap(),
                quantity: Decimal::from_f64_retain(q).unwrap(),
                order_count: 1,
            })
            .collect()
    }

    #[test]
    fn test_weighted_order_imbalance() {
        let bids = create_test_levels(&[100.0, 99.5, 99.0], &[10.0, 20.0, 30.0]);
        let asks = create_test_levels(&[100.5, 101.0, 101.5], &[15.0, 25.0, 35.0]);

        let imbalance = calculate_weighted_order_imbalance(&bids, &asks, 3);
        assert!((-1.0..=1.0).contains(&imbalance));
    }

    #[test]
    fn test_relative_spread() {
        let bids = create_test_levels(&[100.0], &[10.0]);
        let asks = create_test_levels(&[100.5], &[10.0]);

        let spread = calculate_relative_spread(&bids, &asks);
        assert!((spread - 0.004988).abs() < 0.000001); // 0.5 / 100.25 ≈ 0.004988
    }

    #[test]
    fn test_advanced_vpin() {
        let mut calculator = AdvancedVPINCalculator::new(dec!(100), 10);

        // Add trades
        calculator.add_trade(&TradeTick {
            timestamp_ns: 1000,
            symbol: "TEST".to_string(),
            side: TradeSide::Buy,
            price: dec!(100),
            quantity: dec!(60),
        });

        calculator.add_trade(&TradeTick {
            timestamp_ns: 2000,
            symbol: "TEST".to_string(),
            side: TradeSide::Sell,
            price: dec!(100),
            quantity: dec!(40),
        });

        let vpin = calculator.calculate();
        assert!((0.0..=1.0).contains(&vpin));
    }

    #[test]
    fn test_price_run() {
        let mut calculator = PriceRunCalculator::new(5);

        // Create snapshots with increasing prices
        for i in 0..10 {
            let price = 100.0 + i as f64;
            let snapshot = OrderBookSnapshot {
                timestamp_ns: i * 1000,
                symbol: "TEST".to_string(),
                bids: create_test_levels(&[price - 0.5], &[10.0]),
                asks: create_test_levels(&[price + 0.5], &[10.0]),
            };

            let run = calculator.update(&snapshot);
            if i > 0 {
                assert!(!run.is_nan());
            }
        }
    }

    #[test]
    fn test_liquidity_shock_ratio() {
        let bids = create_test_levels(
            &[100.0, 99.5, 99.0, 98.5, 98.0],
            &[10.0, 20.0, 30.0, 40.0, 50.0],
        );
        let asks = create_test_levels(
            &[100.5, 101.0, 101.5, 102.0, 102.5],
            &[15.0, 25.0, 35.0, 45.0, 55.0],
        );

        let ratio = calculate_liquidity_shock_ratio(&bids, &asks, 2);
        assert!((0.0..=1.0).contains(&ratio));
    }

    #[test]
    fn test_exponential_decay_calculator() {
        let mut calculator = ExponentialDecayCalculator::new(10);

        // Add some values
        for i in 1..=20 {
            calculator.update(i as f64);
        }

        // Check that calculations are reasonable
        assert!(calculator.get_mean() > 0.0);
        assert!(calculator.get_std() >= 0.0);
        assert!(calculator.get_var() >= 0.0);
    }

    #[test]
    fn test_rolling_price_impact() {
        let mut calculator = RollingPriceImpactCalculator::new(5);

        for i in 1..=10 {
            let trade = TradeTick {
                timestamp_ns: i * 1000,
                symbol: "TEST".to_string(),
                side: TradeSide::Buy,
                price: dec!(100) + Decimal::from(i),
                quantity: dec!(10) + Decimal::from(i),
            };

            let impact = calculator.add_trade(&trade);
            if i > 2 {
                assert!(!impact.is_nan());
            }
        }
    }

    #[test]
    fn test_volume_price_sensitivity() {
        let mut calculator = VolumePriceSensitivityCalculator::new(5);

        for i in 1..=10 {
            let trade = TradeTick {
                timestamp_ns: i * 1000,
                symbol: "TEST".to_string(),
                side: TradeSide::Buy,
                price: dec!(100) + Decimal::from(i % 3), // Some price variation
                quantity: dec!(10) + Decimal::from(i),
            };

            let sensitivity = calculator.add_trade(&trade);
            if i > 1 {
                // Should eventually get a valid value
                println!("Sensitivity at {i}: {sensitivity}");
            }
        }
    }

    #[test]
    fn test_price_entropy() {
        let mut calculator = PriceEntropyCalculator::new(20);

        // Add prices with some pattern
        for i in 1..=50 {
            let price = dec!(100) + Decimal::from(i % 5); // Cyclical pattern
            let entropy = calculator.update(price);

            if i > 15 {
                assert!(!entropy.is_nan());
                assert!(entropy >= 0.0);
            }
        }
    }

    #[test]
    fn test_multi_level_ofi_detailed() {
        let prev_bids = create_test_levels(&[100.0, 99.5, 99.0], &[10.0, 20.0, 30.0]);
        let prev_asks = create_test_levels(&[100.5, 101.0, 101.5], &[15.0, 25.0, 35.0]);

        // Modified volumes
        let curr_bids = create_test_levels(&[100.0, 99.5, 99.0], &[12.0, 18.0, 32.0]);
        let curr_asks = create_test_levels(&[100.5, 101.0, 101.5], &[13.0, 27.0, 33.0]);

        let ofi =
            calculate_multi_level_ofi_detailed(&prev_bids, &prev_asks, &curr_bids, &curr_asks);
        assert!(!ofi.is_nan());
    }

    #[test]
    fn test_trading_burst_detector() {
        let mut detector = TradingBurstDetector::new(5);

        for i in 1..=10 {
            let trade = TradeTick {
                timestamp_ns: i * 1000,
                symbol: "TEST".to_string(),
                side: TradeSide::Buy,
                price: dec!(100),
                quantity: dec!(10) + Decimal::from(i * i), // Increasing variance
            };

            let burst = detector.add_trade(&trade);
            if i > 2 {
                assert!(!burst.is_nan());
                assert!(burst >= 0.0);
            }
        }
    }
}