rusty_backtest/features/

tardis_advanced.rs

//! Advanced Tardis Features - Missing Implementations
//!
//! This module contains the remaining advanced microstructure features
//! that were specified in the TDD requirements but not yet implemented.

#[cfg(test)]
use super::TradeSide;
use super::tardis_features::{
    ExponentialDecayCalculator, PriceEntropyCalculator, RollingPriceImpactCalculator,
    TradingBurstDetector, VolumePriceSensitivityCalculator,
};
use super::{OrderBookSnapshot, TradeTick};
use rust_decimal::Decimal;
use rust_decimal::prelude::ToPrimitive;
use std::collections::VecDeque;

/// Validated trade with pre-converted f64 values to ensure atomic updates
/// This prevents partial feature updates when Decimal to f64 conversions fail
///
/// The pre-converted f64 values serve as validation that the conversions will succeed
/// even if the underlying feature calculators perform their own conversions internally
#[allow(dead_code)] // Fields are used for validation, not direct access
struct ValidatedTrade<'a> {
    trade: &'a TradeTick,
    price_f64: f64,
    quantity_f64: f64,
}

/// Harmonic Oscillator for detecting cyclical patterns
///
/// Detects cyclical patterns via rolling volatility analysis using short and long windows
pub struct HarmonicOscillator {
    short_window: VecDeque<f64>,
    long_window: VecDeque<f64>,
    short_size: usize,
    long_size: usize,
}

/// Result of harmonic oscillation detection
#[derive(Debug, Clone)]
pub struct HarmonicResult {
    /// Detected oscillation frequency (ratio of short to long volatility)
    pub frequency: f64,
    /// Amplitude of price oscillations (half of price range)
    pub amplitude: Decimal,
    /// Phase angle of the oscillation pattern in radians
    pub phase: f64,
}

impl HarmonicOscillator {
    /// Create a new harmonic oscillator with short and long window sizes
    #[must_use]
    pub fn new(short_window_size: usize, long_window_size: usize) -> Self {
        Self {
            short_window: VecDeque::with_capacity(short_window_size),
            long_window: VecDeque::with_capacity(long_window_size),
            short_size: short_window_size,
            long_size: long_window_size,
        }
    }

    /// Update the oscillator with a new price
    ///
    /// Returns true if the update was successful, false if price conversion failed
    pub fn update(&mut self, price: Decimal) -> bool {
        // Skip update if price cannot be converted to f64 to avoid corrupting calculations
        let price_f64 = match price.to_f64() {
            Some(p) => p,
            None => {
                // Log error in debug builds - invalid price value
                #[cfg(debug_assertions)]
                eprintln!(
                    "Warning: Failed to convert price {price} to f64, skipping oscillator update"
                );
                return false;
            }
        };

        // Add to both windows
        self.short_window.push_back(price_f64);
        self.long_window.push_back(price_f64);

        // Maintain window sizes
        if self.short_window.len() > self.short_size {
            self.short_window.pop_front();
        }
        if self.long_window.len() > self.long_size {
            self.long_window.pop_front();
        }

        true
    }

    /// Detect harmonic oscillations
    #[must_use]
    pub fn detect_oscillation(&self) -> HarmonicResult {
        if self.long_window.len() < self.long_size {
            return HarmonicResult {
                frequency: 0.0,
                amplitude: Decimal::ZERO,
                phase: 0.0,
            };
        }

        // Calculate short and long volatilities
        let short_vol = self.calculate_volatility(&self.short_window);
        let long_vol = self.calculate_volatility(&self.long_window);

        // Frequency estimation based on volatility ratio
        let frequency = if long_vol > 0.0 {
            short_vol / long_vol
        } else {
            0.0
        };

        // Amplitude estimation from price range
        let prices: Vec<f64> = self.long_window.iter().copied().collect();
        let min_price = prices.iter().fold(f64::INFINITY, |a, &b| a.min(b));
        let max_price = prices.iter().fold(f64::NEG_INFINITY, |a, &b| a.max(b));
        let amplitude =
            Decimal::from_f64_retain((max_price - min_price) / 2.0).unwrap_or(Decimal::ZERO);

        // Simple phase estimation using correlation with sine wave
        let phase = self.estimate_phase(&prices);

        HarmonicResult {
            frequency,
            amplitude,
            phase,
        }
    }

    /// Calculate volatility (standard deviation) of a price window
    fn calculate_volatility(&self, window: &VecDeque<f64>) -> f64 {
        if window.len() < 2 {
            return 0.0;
        }

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

        variance.sqrt()
    }

    /// Estimate phase by finding best correlation with sine wave
    fn estimate_phase(&self, prices: &[f64]) -> f64 {
        if prices.len() < 10 {
            return 0.0;
        }

        let mut best_correlation: f64 = 0.0;
        let mut best_phase: f64 = 0.0;

        // Try different phases
        for phase_steps in 0..20 {
            let phase = (phase_steps as f64) * std::f64::consts::PI / 10.0;
            let correlation = self.calculate_sine_correlation(prices, phase);

            if correlation.abs() > best_correlation.abs() {
                best_correlation = correlation;
                best_phase = phase;
            }
        }

        best_phase
    }

    /// Calculate correlation between prices and sine wave with given phase
    fn calculate_sine_correlation(&self, prices: &[f64], phase: f64) -> f64 {
        if prices.is_empty() {
            return 0.0;
        }

        let n = prices.len();
        let frequency = 2.0 * std::f64::consts::PI / n as f64;

        let mut sum_xy = 0.0;
        let mut sum_x = 0.0;
        let mut sum_y = 0.0;
        let mut sum_x2 = 0.0;
        let mut sum_y2 = 0.0;

        for (i, &price) in prices.iter().enumerate() {
            let sine_val = (frequency * i as f64 + phase).sin();

            sum_xy += price * sine_val;
            sum_x += price;
            sum_y += sine_val;
            sum_x2 += price * price;
            sum_y2 += sine_val * sine_val;
        }

        let n_f64 = n as f64;
        let numerator = n_f64 * sum_xy - sum_x * sum_y;
        let denominator =
            ((n_f64 * sum_x2 - sum_x * sum_x) * (n_f64 * sum_y2 - sum_y * sum_y)).sqrt();

        if denominator != 0.0 {
            numerator / denominator
        } else {
            0.0
        }
    }
}

/// Order Type Tracker for limit/market order ratios
///
/// Tracks market aggressiveness via order type ratios.
///
/// **Warning**: Order type inference from trade data is inherently unreliable
/// since most exchanges don't provide order type information in their trade feeds.
/// This tracker should be used for statistical analysis only, not for critical
/// trading decisions.
pub struct OrderTypeTracker {
    limit_orders: u64,
    market_orders: u64,
    unknown_orders: u64,
}

impl OrderTypeTracker {
    /// Create a new order type tracker
    #[must_use]
    pub const fn new() -> Self {
        Self {
            limit_orders: 0,
            market_orders: 0,
            unknown_orders: 0,
        }
    }

    /// Add an order to the tracker
    pub const fn add_order(&mut self, order_type: OrderType) {
        match order_type {
            OrderType::Limit => self.limit_orders += 1,
            OrderType::Market => self.market_orders += 1,
            OrderType::Unknown => self.unknown_orders += 1,
        }
    }

    /// Calculate limit to market order ratio
    #[must_use]
    pub fn limit_to_market_ratio(&self) -> Option<Decimal> {
        if self.market_orders == 0 {
            return None;
        }
        Some(Decimal::from(self.limit_orders) / Decimal::from(self.market_orders))
    }

    /// Calculate market aggressiveness (market orders / total known orders)
    ///
    /// Note: This calculation excludes unknown orders since their type cannot be determined.
    /// Only considers orders classified as either limit or market.
    #[must_use]
    pub fn market_aggressiveness(&self) -> Decimal {
        let total_known = self.limit_orders + self.market_orders;
        if total_known == 0 {
            return Decimal::ZERO;
        }
        Decimal::from(self.market_orders) / Decimal::from(total_known)
    }

    /// Reset counters
    pub const fn reset(&mut self) {
        self.limit_orders = 0;
        self.market_orders = 0;
        self.unknown_orders = 0;
    }

    /// Get order counts (limit, market, unknown)
    #[must_use]
    pub const fn get_counts(&self) -> (u64, u64, u64) {
        (self.limit_orders, self.market_orders, self.unknown_orders)
    }

    /// Get only limit and market order counts for backward compatibility
    #[must_use]
    pub const fn get_known_counts(&self) -> (u64, u64) {
        (self.limit_orders, self.market_orders)
    }

    /// Get the number of unknown orders
    #[must_use]
    pub const fn unknown_count(&self) -> u64 {
        self.unknown_orders
    }

    /// Get the total number of orders (including unknown)
    #[must_use]
    pub const fn total_count(&self) -> u64 {
        self.limit_orders + self.market_orders + self.unknown_orders
    }
}

/// Order type enumeration
///
/// Note: Order type inference from trade data is inherently unreliable since
/// most exchanges don't provide this information in trade feeds. The Unknown
/// variant should be used when order type cannot be reliably determined.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum OrderType {
    /// Limit order (passive order that adds liquidity)
    Limit,
    /// Market order (aggressive order that takes liquidity)
    Market,
    /// Order type cannot be reliably determined from available trade data
    Unknown,
}

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

/// Configuration for Tardis Advanced Features
#[derive(Debug, Clone)]
pub struct TardisConfig {
    /// Window size for exponential decay calculations
    pub decay_span: usize,
    /// Window size for rolling price impact calculations
    pub price_impact_window: usize,
    /// Window size for volume-price sensitivity calculations
    pub volume_sensitivity_window: usize,
    /// Window size for price entropy calculations
    pub entropy_window: usize,
    /// Window size for burst detection
    pub burst_detector_window: usize,
    /// Short window size for harmonic oscillator
    pub harmonic_short_window: usize,
    /// Long window size for harmonic oscillator
    pub harmonic_long_window: usize,
    /// Enable experimental order type inference (default: false)
    ///
    /// Warning: Order type inference from trade data is inherently unreliable
    /// and should only be used for statistical analysis, not trading decisions.
    pub enable_order_type_inference: bool,
}

impl Default for TardisConfig {
    fn default() -> Self {
        Self {
            decay_span: 20,
            price_impact_window: 100,
            volume_sensitivity_window: 50,
            entropy_window: 100,
            burst_detector_window: 100,
            harmonic_short_window: 50,
            harmonic_long_window: 200,
            // Disabled by default for safety - order type inference is unreliable
            enable_order_type_inference: false,
        }
    }
}

/// Consolidated Tardis Advanced Features
///
/// Integrates all advanced microstructure features into a single interface
pub struct TardisAdvancedFeatures {
    decay_calculator: ExponentialDecayCalculator,
    impact_tracker: RollingPriceImpactCalculator,
    oscillator: HarmonicOscillator,
    burst_detector: TradingBurstDetector,
    sensitivity: VolumePriceSensitivityCalculator,
    order_tracker: OrderTypeTracker,
    entropy: PriceEntropyCalculator,
    // Cached values from last calculation
    last_price_impact: f64,
    last_burst_intensity: f64,
    last_volume_price_sensitivity: f64,
    last_price_entropy: f64,
    // Store config for get_config method
    config: TardisConfig,
}

/// Feature vector containing all calculated features
#[derive(Debug, Clone)]
pub struct TardisFeatureVector {
    /// Exponentially weighted mean price
    pub exponential_mean: f64,
    /// Exponentially weighted standard deviation
    pub exponential_std: f64,
    /// Exponentially weighted variance
    pub exponential_var: f64,
    /// Rolling Kyle's lambda (permanent price impact)
    pub price_impact: f64,
    /// Detected harmonic oscillation frequency
    pub harmonic_frequency: f64,
    /// Detected harmonic oscillation amplitude
    pub harmonic_amplitude: Decimal,
    /// Detected harmonic oscillation phase
    pub harmonic_phase: f64,
    /// Trading burst intensity (volume volatility)
    pub burst_intensity: f64,
    /// Sensitivity of price to volume changes
    pub volume_price_sensitivity: f64,
    /// Ratio of limit orders to market orders (None if no market orders)
    pub limit_market_ratio: Option<Decimal>,
    /// Proportion of market orders to total known orders
    pub market_aggressiveness: Decimal,
    /// Shannon entropy of price distribution
    pub price_entropy: f64,
    /// Number of orders with unknown type (new field)
    pub unknown_order_count: u64,
    /// Total number of orders processed
    pub total_order_count: u64,
}

impl TardisAdvancedFeatures {
    /// Create new Tardis advanced features with configuration
    #[must_use]
    pub fn new(config: TardisConfig) -> Self {
        Self {
            decay_calculator: ExponentialDecayCalculator::new(config.decay_span),
            impact_tracker: RollingPriceImpactCalculator::new(config.price_impact_window),
            oscillator: HarmonicOscillator::new(
                config.harmonic_short_window,
                config.harmonic_long_window,
            ),
            burst_detector: TradingBurstDetector::new(config.burst_detector_window),
            sensitivity: VolumePriceSensitivityCalculator::new(config.volume_sensitivity_window),
            order_tracker: OrderTypeTracker::new(),
            entropy: PriceEntropyCalculator::new(config.entropy_window),
            // Initialize cached values
            last_price_impact: 0.0,
            last_burst_intensity: 0.0,
            last_volume_price_sensitivity: 0.0,
            last_price_entropy: 0.0,
            // Store config
            config,
        }
    }

    /// Update all features with a new market tick (trade)
    pub fn update_with_trade(&mut self, trade: &TradeTick) -> Result<(), &'static str> {
        // Pre-convert all required Decimal values to f64 to ensure atomic updates
        let price_f64 = match trade.price.to_f64() {
            Some(p) => p,
            None => {
                // Log error in debug builds - invalid trade price
                #[cfg(debug_assertions)]
                eprintln!(
                    "Warning: Failed to convert trade price {} to f64, skipping all feature updates",
                    trade.price
                );
                return Err("Failed to convert trade price to f64");
            }
        };

        let quantity_f64 = match trade.quantity.to_f64() {
            Some(q) => q,
            None => {
                // Log error in debug builds - invalid trade quantity
                #[cfg(debug_assertions)]
                eprintln!(
                    "Warning: Failed to convert trade quantity {} to f64, skipping all feature updates",
                    trade.quantity
                );
                return Err("Failed to convert trade quantity to f64");
            }
        };

        // Create a validated trade snapshot with pre-converted values
        let validated_trade = ValidatedTrade {
            trade,
            price_f64,
            quantity_f64,
        };

        // Update all features atomically - if any fail, the entire update fails
        // This ensures consistent state across all features

        // Update price-based features
        self.decay_calculator.update(price_f64);
        self.update_harmonic_oscillator_safe(trade.price)?;
        self.last_price_entropy = self.entropy.update(trade.price);

        // Update trade-based features with validated data
        self.last_price_impact = self.update_price_impact_safe(&validated_trade)?;
        self.last_burst_intensity = self.update_burst_detector_safe(&validated_trade)?;
        self.last_volume_price_sensitivity =
            self.update_volume_sensitivity_safe(&validated_trade)?;

        // Order type inference - mark as unknown since we don't have reliable indicators
        let order_type = self.infer_order_type(trade);
        self.order_tracker.add_order(order_type);

        Ok(())
    }

    /// Update with order book snapshot
    pub fn update_with_snapshot(
        &mut self,
        snapshot: &OrderBookSnapshot,
    ) -> Result<(), &'static str> {
        let mid_price = snapshot.mid_price();
        // Convert mid price to f64 first to ensure all features can be updated consistently
        let mid_price_f64 = match mid_price.to_f64() {
            Some(p) => p,
            None => {
                // Log error in debug builds - invalid mid price
                #[cfg(debug_assertions)]
                eprintln!(
                    "Warning: Failed to convert mid price {mid_price} to f64, skipping all feature updates"
                );
                return Err("Failed to convert mid price to f64");
            }
        };

        // Update all features atomically
        self.decay_calculator.update(mid_price_f64);
        self.update_harmonic_oscillator_safe(mid_price)?;
        self.last_price_entropy = self.entropy.update(mid_price);

        Ok(())
    }

    /// Safe harmonic oscillator update that handles conversion failures gracefully
    fn update_harmonic_oscillator_safe(&mut self, price: Decimal) -> Result<(), &'static str> {
        // Use the new return value from oscillator update to check success
        if self.oscillator.update(price) {
            Ok(())
        } else {
            #[cfg(debug_assertions)]
            log::warn!("Failed to update harmonic oscillator with price {price}");
            Err("Failed to update harmonic oscillator")
        }
    }

    /// Safe price impact update that validates conversions before updating
    fn update_price_impact_safe(
        &mut self,
        validated_trade: &ValidatedTrade,
    ) -> Result<f64, &'static str> {
        // Validate input values are not NaN (should not happen with ValidatedTrade, but defense in depth)
        if validated_trade.price_f64.is_nan() {
            log::warn!("Price impact calculation skipped: price is NaN");
            return Err("Price is NaN in validated trade");
        }

        if validated_trade.quantity_f64.is_nan() {
            log::warn!("Price impact calculation skipped: quantity is NaN");
            return Err("Quantity is NaN in validated trade");
        }

        // Use the trade with pre-validated conversions
        // The impact tracker internally converts decimals, so we still need to handle potential failures
        let impact = self.impact_tracker.add_trade(validated_trade.trade);

        // NaN is expected for initial calculations with insufficient data
        // Check if NaN might be due to calculation error vs insufficient data
        if impact.is_nan() {
            // Log warning for debugging, but don't treat as error since NaN is expected initially
            #[cfg(debug_assertions)]
            log::debug!(
                "Price impact calculation returned NaN (may be expected for initial state)"
            );
        }

        Ok(impact) // Return the result, even if it's NaN (expected for initial state)
    }

    /// Safe burst detector update that validates conversions before updating
    fn update_burst_detector_safe(
        &mut self,
        validated_trade: &ValidatedTrade,
    ) -> Result<f64, &'static str> {
        // Use the trade with pre-validated conversions
        let burst = self.burst_detector.add_trade(validated_trade.trade);

        // NaN is expected for initial calculations with insufficient data
        Ok(burst) // Always return the result, even if it's NaN (expected for initial state)
    }

    /// Safe volume sensitivity update that validates conversions before updating
    fn update_volume_sensitivity_safe(
        &mut self,
        validated_trade: &ValidatedTrade,
    ) -> Result<f64, &'static str> {
        // Use the trade with pre-validated conversions
        let sensitivity = self.sensitivity.add_trade(validated_trade.trade);

        // NaN is expected for initial calculations with insufficient data
        Ok(sensitivity) // Always return the result, even if it's NaN (expected for initial state)
    }

    /// Get all calculated features as a feature vector
    #[must_use]
    pub fn get_features(&self) -> TardisFeatureVector {
        let harmonic_result = self.oscillator.detect_oscillation();

        TardisFeatureVector {
            exponential_mean: self.decay_calculator.get_mean(),
            exponential_std: self.decay_calculator.get_std(),
            exponential_var: self.decay_calculator.get_var(),
            price_impact: self.last_price_impact,
            harmonic_frequency: harmonic_result.frequency,
            harmonic_amplitude: harmonic_result.amplitude,
            harmonic_phase: harmonic_result.phase,
            burst_intensity: self.last_burst_intensity,
            volume_price_sensitivity: self.last_volume_price_sensitivity,
            limit_market_ratio: self.order_tracker.limit_to_market_ratio(),
            market_aggressiveness: self.order_tracker.market_aggressiveness(),
            price_entropy: self.last_price_entropy,
            unknown_order_count: self.order_tracker.unknown_count(),
            total_order_count: self.order_tracker.total_count(),
        }
    }

    /// Reset all calculators
    pub const fn reset(&mut self) {
        self.order_tracker.reset();
        // Note: Other calculators maintain their state for continuity
    }

    /// Infer order type from trade characteristics
    ///
    /// This method replaces the unreliable quantity > 10.0 heuristic with a more
    /// cautious approach that returns Unknown by default, with optional experimental
    /// inference when enabled in configuration.
    #[must_use]
    const fn infer_order_type(&self, _trade: &TradeTick) -> OrderType {
        // For now, always return Unknown since we don't have reliable order type indicators
        // in trade data. Future implementations could add:
        // - Price impact analysis (distance from mid-price)
        // - Symbol-specific adaptive thresholds
        // - Multi-factor scoring

        if self.config.enable_order_type_inference {
            // Future: implement experimental inference here
            // For now, still return Unknown even when enabled
            OrderType::Unknown
        } else {
            OrderType::Unknown
        }
    }

    /// Get configuration used
    #[must_use]
    pub fn get_config(&self) -> TardisConfig {
        self.config.clone()
    }
}

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

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

    #[test]
    fn test_harmonic_oscillations() {
        let mut oscillator = HarmonicOscillator::new(50, 200);

        // Generate sine wave pattern
        for i in 0..300 {
            let price = 100.0 + 5.0 * (i as f64 * 0.1).sin();
            let success = oscillator.update(Decimal::from_f64_retain(price).unwrap());
            assert!(
                success,
                "Harmonic oscillator update should succeed for valid price"
            );
        }

        let harmonics = oscillator.detect_oscillation();
        assert!(harmonics.frequency > 0.0);
        assert!(harmonics.amplitude > dec!(4.0));
    }

    #[test]
    fn test_limit_market_order_ratio() {
        let mut tracker = OrderTypeTracker::new();

        // Add orders
        for _ in 0..70 {
            tracker.add_order(OrderType::Limit);
        }
        for _ in 0..30 {
            tracker.add_order(OrderType::Market);
        }

        let ratio = tracker.limit_to_market_ratio();
        assert!(ratio.is_some());
        assert!((ratio.unwrap() - dec!(2.33)).abs() < dec!(0.01));

        let aggressiveness = tracker.market_aggressiveness();
        assert!((aggressiveness - dec!(0.30)).abs() < dec!(0.01));

        // Test counts
        assert_eq!(tracker.get_counts(), (70, 30, 0));
        assert_eq!(tracker.total_count(), 100);
        assert_eq!(tracker.unknown_count(), 0);
    }

    #[test]
    fn test_tardis_advanced_features_integration() {
        let config = TardisConfig::default();
        let mut features = TardisAdvancedFeatures::new(config);

        // Create a test trade
        let trade = TradeTick {
            timestamp_ns: 1000000000,
            symbol: "BTCUSDT".to_string(),
            side: TradeSide::Buy,
            price: dec!(50000.0),
            quantity: dec!(1.5),
        };

        // Update features
        let update_result = features.update_with_trade(&trade);
        assert!(
            update_result.is_ok(),
            "Valid trade should update successfully"
        );

        // Get feature vector
        let feature_vector = features.get_features();

        // Verify features are calculated
        assert!(!feature_vector.exponential_mean.is_nan());
        assert!(feature_vector.exponential_std >= 0.0);
        assert!(feature_vector.exponential_var >= 0.0);
        assert!(feature_vector.harmonic_frequency >= 0.0);
        assert!(feature_vector.harmonic_amplitude >= Decimal::ZERO);
        // limit_market_ratio is None when no market orders have been added
        assert!(
            feature_vector.limit_market_ratio.is_none()
                || feature_vector.limit_market_ratio.unwrap() >= Decimal::ZERO
        );
        assert!(feature_vector.market_aggressiveness >= Decimal::ZERO);

        // New fields should be populated (using explicit checks to verify they exist)
        let _ = feature_vector.unknown_order_count; // Ensure field exists
        let _ = feature_vector.total_order_count; // Ensure field exists

        // Since we're using Unknown order type inference, unknown count should be > 0
        assert!(feature_vector.unknown_order_count > 0);
    }

    #[test]
    fn test_order_type_inference_returns_unknown() {
        let config = TardisConfig::default();
        let features = TardisAdvancedFeatures::new(config);

        // Create test trades with different quantities
        let small_trade = TradeTick {
            timestamp_ns: 1000000000,
            symbol: "BTCUSDT".to_string(),
            side: TradeSide::Buy,
            price: dec!(50000.0),
            quantity: dec!(0.1), // Small quantity
        };

        let large_trade = TradeTick {
            timestamp_ns: 1000000000,
            symbol: "BTCUSDT".to_string(),
            side: TradeSide::Buy,
            price: dec!(50000.0),
            quantity: dec!(100.0), // Large quantity (> 10.0)
        };

        // Both trades should return Unknown regardless of quantity
        assert_eq!(features.infer_order_type(&small_trade), OrderType::Unknown);
        assert_eq!(features.infer_order_type(&large_trade), OrderType::Unknown);
    }

    #[test]
    fn test_order_type_tracker_reset() {
        let mut tracker = OrderTypeTracker::new();

        tracker.add_order(OrderType::Limit);
        tracker.add_order(OrderType::Market);

        assert_eq!(tracker.get_counts(), (1, 1, 0));

        tracker.reset();
        assert_eq!(tracker.get_counts(), (0, 0, 0));
    }

    #[test]
    fn test_harmonic_oscillator_empty_windows() {
        let oscillator = HarmonicOscillator::new(10, 20);
        let result = oscillator.detect_oscillation();

        assert_eq!(result.frequency, 0.0);
        assert_eq!(result.amplitude, Decimal::ZERO);
        assert_eq!(result.phase, 0.0);
    }

    #[test]
    fn test_order_tracker_edge_cases() {
        let tracker = OrderTypeTracker::new();

        // Test with no orders
        assert_eq!(tracker.limit_to_market_ratio(), None);
        assert_eq!(tracker.market_aggressiveness(), Decimal::ZERO);
    }

    #[test]
    fn test_unknown_order_type_handling() {
        let mut tracker = OrderTypeTracker::new();

        // Add mixed order types including unknown
        tracker.add_order(OrderType::Limit);
        tracker.add_order(OrderType::Market);
        tracker.add_order(OrderType::Unknown);
        tracker.add_order(OrderType::Unknown);

        // Test counts
        assert_eq!(tracker.get_counts(), (1, 1, 2));
        assert_eq!(tracker.get_known_counts(), (1, 1));
        assert_eq!(tracker.unknown_count(), 2);
        assert_eq!(tracker.total_count(), 4);

        // Market aggressiveness should only consider known orders
        let aggressiveness = tracker.market_aggressiveness();
        assert_eq!(aggressiveness, dec!(0.5)); // 1 market / (1 limit + 1 market)

        // Reset should clear all counters
        tracker.reset();
        assert_eq!(tracker.get_counts(), (0, 0, 0));
    }

    #[test]
    fn test_tardis_config_default() {
        let config = TardisConfig::default();

        assert_eq!(config.decay_span, 20);
        assert_eq!(config.price_impact_window, 100);
        assert_eq!(config.harmonic_short_window, 50);
        assert_eq!(config.harmonic_long_window, 200);
        assert!(!config.enable_order_type_inference); // Should be disabled by default
    }

    #[test]
    fn test_atomic_update_behavior() {
        let config = TardisConfig::default();
        let mut features = TardisAdvancedFeatures::new(config);

        // Test successful update
        let valid_trade = TradeTick {
            timestamp_ns: 1000000000,
            symbol: "BTCUSDT".to_string(),
            side: TradeSide::Buy,
            price: dec!(50000.0),
            quantity: dec!(1.5),
        };

        let result = features.update_with_trade(&valid_trade);
        assert!(result.is_ok(), "Valid trade should update successfully");

        // Test with another valid trade to ensure consistency
        let valid_trade2 = TradeTick {
            timestamp_ns: 2000000000,
            symbol: "BTCUSDT".to_string(),
            side: TradeSide::Sell,
            price: dec!(49500.0),
            quantity: dec!(2.0),
        };

        let result = features.update_with_trade(&valid_trade2);
        assert!(
            result.is_ok(),
            "Second valid trade should also update successfully"
        );

        // Verify that updates maintain consistent state
        let feature_vector = features.get_features();
        assert!(!feature_vector.exponential_mean.is_nan());
        assert!(feature_vector.exponential_std >= 0.0);
        assert!(feature_vector.exponential_var >= 0.0);
        assert!(feature_vector.total_order_count >= 2);
    }

    #[test]
    fn test_harmonic_oscillator_conversion_failure() {
        let mut oscillator = HarmonicOscillator::new(10, 20);

        // Test with valid price first
        let valid_price = dec!(100.0);
        let success = oscillator.update(valid_price);
        assert!(success, "Valid price should succeed");

        // Test with the maximum valid decimal value
        let large_decimal = Decimal::MAX;
        let success = oscillator.update(large_decimal);
        // This should succeed because Decimal::MAX converts to f64::INFINITY
        assert!(success, "Large decimal should still succeed");

        // Test with minimum value
        let min_decimal = Decimal::MIN;
        let success = oscillator.update(min_decimal);
        // This should also succeed
        assert!(success, "Minimum decimal should still succeed");
    }
}