rusty_feeder/provider/

ext.rs

//! Extension trait for Provider to provide additional functionality
//!
//! This module provides an extension trait that adds convenience methods
//! to all Provider implementations, making them easier to use in a unified way.

use anyhow::Result;
use async_trait::async_trait;
use rusty_model::{
    data::{book_snapshot::OrderBookSnapshot, market_trade::MarketTrade},
    instruments::{Instrument, InstrumentId},
};

use super::connection::ConnectionStats;
use crate::exchange::binance::futures::provider::{
    BinanceFuturesMarketType, BinanceFuturesProvider,
};

// Re-export all sub-modules
pub mod alerts;
pub mod health;
pub mod metrics;

// Re-export all types from sub-modules for convenience
pub use alerts::{AlertCondition, AlertConfig, AlertHandle, AnomalyAlgorithm, AnomalyConfig};
pub use health::{ComponentHealth, HealthIssue, HealthState, HealthStatus, IssueSeverity};
pub use metrics::{
    AggregatedMetrics, CustomMetric, ExecutionQualityMetrics, InstrumentMetrics, LatencyBucket,
    LatencyDistribution, LatencyMetrics, MetricsCollector, MicrostructureSignals, OrderFlowMetrics,
    TradingMetrics,
};

/// Data handler trait for processing market data
#[async_trait]
pub trait DataHandler: Send + Sync {
    /// Handle incoming market trade
    async fn handle_market_trade(&self, trade: MarketTrade) -> Result<()>;

    /// Handle incoming orderbook snapshot
    async fn handle_orderbook_snapshot(&self, snapshot: OrderBookSnapshot) -> Result<()>;
}

/// Advanced monitoring capabilities for High-Frequency Trading (HFT) systems
///
/// The `MonitorExt` trait provides comprehensive monitoring, alerting, and observability features
/// specifically designed for HFT systems that require nanosecond precision and real-time performance
/// tracking. This trait extends basic monitoring with advanced analytics including:
///
/// - **Real-time Performance Metrics**: Track latency distributions, throughput, and system health
/// - **Trading Analytics**: Monitor order flow, market impact, and microstructure signals
/// - **Anomaly Detection**: Identify unusual patterns in trading data and system behavior
/// - **Alerting System**: Configure alerts for critical conditions with customizable thresholds
/// - **Health Monitoring**: Component-level health tracking with degradation detection
/// - **Custom Metrics**: Extensible framework for domain-specific metric collection
///
/// # Design Philosophy
///
/// The trait is designed with HFT requirements in mind:
/// - All timestamps use nanosecond precision
/// - Zero-allocation operations where possible
/// - Lock-free metrics collection for minimal overhead
/// - Configurable aggregation intervals to balance accuracy vs performance
///
/// # Usage Example
///
/// ```rust,no_run
/// use rusty_feeder::provider::ext::{MonitorExt, AlertConfig, AlertCondition, IssueSeverity};
/// use rusty_model::instruments::InstrumentId;
/// use rusty_model::venues::Venue;
///
/// async fn monitor_trading_system(monitor: &impl MonitorExt) -> anyhow::Result<()> {
///     // Configure latency alert
///     let alert_config = AlertConfig {
///         name: "High Latency Alert".to_string(),
///         condition: AlertCondition::LatencyThreshold { instrument_id: None },
///         threshold: 1_000_000.0, // 1ms in nanoseconds
///         duration_ms: 5000,      // Trigger after 5 seconds
///         severity: IssueSeverity::Warning,
///         enabled: true,
///     };
///
///     let alert_handle = monitor.enable_alert(alert_config).await?;
///
///     // Get real-time metrics
///     let btc_usdt = InstrumentId::new("BTC-USDT", Venue::Binance);
///     let metrics = monitor.get_instrument_metrics(&btc_usdt).await?;
///     println!("Current latency: {}ns", metrics.latency_metrics.total_latency_ns);
///
///     // Export for Prometheus
///     let prometheus_data = monitor.export_prometheus_metrics().await?;
///
///     Ok(())
/// }
/// ```
#[async_trait]
pub trait MonitorExt {
    /// Retrieves comprehensive real-time metrics for a specific trading instrument
    ///
    /// This method provides a complete snapshot of all monitoring data for a single instrument,
    /// including connection health, data feed statistics, order flow metrics, and latency
    /// measurements. All metrics use nanosecond precision timestamps.
    ///
    /// # Arguments
    ///
    /// * `instrument_id` - The unique identifier of the instrument to query
    ///
    /// # Returns
    ///
    /// * `Ok(InstrumentMetrics)` - Complete metrics snapshot for the instrument
    /// * `Err` - If the instrument is not found or monitoring is not available
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use rusty_model::instruments::InstrumentId;
    /// # use rusty_model::venues::Venue;
    /// # async fn example(monitor: &impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// let eth_usdt = InstrumentId::new("ETH-USDT", Venue::Binance);
    /// let metrics = monitor.get_instrument_metrics(&eth_usdt).await?;
    ///
    /// // Check order flow imbalance
    /// if metrics.order_flow_metrics.volume_imbalance.abs() > 0.7 {
    ///     println!("High volume imbalance detected: {}", metrics.order_flow_metrics.volume_imbalance);
    /// }
    ///
    /// // Monitor latency
    /// println!("Network latency: {}µs", metrics.latency_metrics.network_latency_ns / 1000);
    /// println!("Total latency: {}µs", metrics.latency_metrics.total_latency_ns / 1000);
    /// # Ok(())
    /// # }
    /// ```
    async fn get_instrument_metrics(
        &self,
        instrument_id: &InstrumentId,
    ) -> Result<InstrumentMetrics>;

    /// Retrieves aggregated metrics across all actively monitored instruments
    ///
    /// This method provides system-wide performance metrics, useful for monitoring overall
    /// system health and identifying cross-instrument issues. Aggregated metrics include
    /// total message throughput, average latencies, memory usage, and health scores.
    ///
    /// # Returns
    ///
    /// * `Ok(AggregatedMetrics)` - System-wide aggregated metrics
    /// * `Err` - If monitoring subsystem is unavailable
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # async fn example(monitor: &impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// let system_metrics = monitor.get_aggregated_metrics().await?;
    ///
    /// // Check system health
    /// if system_metrics.overall_health_score < 0.8 {
    ///     println!("System health degraded: {:.2}", system_metrics.overall_health_score);
    ///     println!("Active alerts: {}", system_metrics.active_alerts);
    /// }
    ///
    /// // Monitor performance
    /// println!("Processing {} messages/sec",
    ///     system_metrics.total_messages_processed / (system_metrics.timestamp / 1_000_000_000));
    /// println!("P99 latency: {}µs", system_metrics.p99_latency_ns / 1000);
    /// # Ok(())
    /// # }
    /// ```
    async fn get_aggregated_metrics(&self) -> Result<AggregatedMetrics>;

    /// Registers a custom metrics collector for domain-specific monitoring
    ///
    /// This method allows extending the monitoring system with custom metrics collectors
    /// that implement the `MetricsCollector` trait. Collectors are invoked periodically
    /// and their metrics are included in aggregated reports and exports.
    ///
    /// # Arguments
    ///
    /// * `collector` - A boxed implementation of the `MetricsCollector` trait
    ///
    /// # Returns
    ///
    /// * `Ok(())` - If the collector was successfully registered
    /// * `Err` - If registration failed (e.g., duplicate name)
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use rusty_feeder::provider::ext::{MetricsCollector, CustomMetric};
    /// # use async_trait::async_trait;
    /// # use anyhow::Result;
    /// # use rustc_hash::FxHashMap;
    ///
    /// struct SpreadMonitor;
    ///
    /// #[async_trait]
    /// impl MetricsCollector for SpreadMonitor {
    ///     async fn collect(&self) -> Result<Vec<CustomMetric>> {
    ///         // Calculate custom spread metrics
    ///         let mut tags = FxHashMap::default();
    ///         tags.insert("exchange".to_string(), "binance".to_string());
    ///
    ///         Ok(vec![
    ///             CustomMetric {
    ///                 name: "custom_spread_bps".to_string(),
    ///                 value: 2.5,
    ///                 tags,
    ///                 timestamp: quanta::Instant::now().as_nanos() as u64,
    ///             }
    ///         ])
    ///     }
    ///
    ///     fn name(&self) -> &str {
    ///         "spread_monitor"
    ///     }
    /// }
    ///
    /// # async fn example(monitor: &mut impl rusty_feeder::provider::ext::MonitorExt) -> Result<()> {
    /// monitor.register_metrics_collector(Box::new(SpreadMonitor)).await?;
    /// # Ok(())
    /// # }
    /// ```
    async fn register_metrics_collector(
        &mut self,
        collector: Box<dyn MetricsCollector>,
    ) -> Result<()>;

    /// Enables a real-time alert for specific monitoring conditions
    ///
    /// This method configures and activates an alert that will trigger when the specified
    /// condition is met for the configured duration. Alerts can monitor various conditions
    /// including latency thresholds, error rates, connection status, and custom metrics.
    ///
    /// # Arguments
    ///
    /// * `alert_config` - Configuration specifying the alert condition, threshold, and behavior
    ///
    /// # Returns
    ///
    /// * `Ok(AlertHandle)` - A handle for managing the active alert
    /// * `Err` - If the alert configuration is invalid
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use rusty_feeder::provider::ext::{AlertConfig, AlertCondition, IssueSeverity};
    /// # use rusty_model::instruments::InstrumentId;
    /// # use rusty_model::venues::Venue;
    /// # async fn example(monitor: &mut impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// // Alert for high latency on specific instrument
    /// let btc_instrument = InstrumentId::new("BTC-USDT", Venue::Binance);
    /// let latency_alert = AlertConfig {
    ///     name: "BTC-USDT High Latency".to_string(),
    ///     condition: AlertCondition::LatencyThreshold {
    ///         instrument_id: Some(btc_instrument),
    ///     },
    ///     threshold: 5_000_000.0,  // 5ms in nanoseconds
    ///     duration_ms: 10_000,     // Sustained for 10 seconds
    ///     severity: IssueSeverity::Error,
    ///     enabled: true,
    /// };
    ///
    /// let alert_handle = monitor.enable_alert(latency_alert).await?;
    ///
    /// // Alert for connection loss
    /// let connection_alert = AlertConfig {
    ///     name: "Binance Connection Lost".to_string(),
    ///     condition: AlertCondition::ConnectionLoss {
    ///         exchange: "binance".to_string(),
    ///     },
    ///     threshold: 1.0,          // Binary condition
    ///     duration_ms: 0,          // Immediate
    ///     severity: IssueSeverity::Critical,
    ///     enabled: true,
    /// };
    ///
    /// let conn_handle = monitor.enable_alert(connection_alert).await?;
    /// # Ok(())
    /// # }
    /// ```
    async fn enable_alert(&mut self, alert_config: AlertConfig) -> Result<AlertHandle>;

    /// Disables an active alert using its handle
    ///
    /// This method deactivates a previously configured alert. The alert will stop
    /// evaluating its condition and no new notifications will be generated.
    ///
    /// # Arguments
    ///
    /// * `handle` - The handle returned when the alert was enabled
    ///
    /// # Returns
    ///
    /// * `Ok(())` - If the alert was successfully disabled
    /// * `Err` - If the handle is invalid or the alert was already disabled
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use rusty_feeder::provider::ext::AlertHandle;
    /// # async fn example(monitor: &mut impl rusty_feeder::provider::ext::MonitorExt, alert_handle: AlertHandle) -> anyhow::Result<()> {
    /// // Disable an alert after market close
    /// monitor.disable_alert(alert_handle).await?;
    /// # Ok(())
    /// # }
    /// ```
    async fn disable_alert(&mut self, handle: AlertHandle) -> Result<()>;

    /// Retrieves the current health status with detailed component diagnostics
    ///
    /// This method provides a comprehensive health check of the monitoring system and
    /// all monitored components. It includes overall system status, individual component
    /// health, active issues, performance grading, and uptime information.
    ///
    /// # Returns
    ///
    /// * `Ok(HealthStatus)` - Detailed health information
    /// * `Err` - If health check fails
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use rusty_feeder::provider::ext::HealthState;
    /// # async fn example(monitor: &impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// let health = monitor.get_health_status().await?;
    ///
    /// match health.overall_status {
    ///     HealthState::Healthy => println!("System healthy - Grade: {}", health.performance_grade),
    ///     HealthState::Degraded => {
    ///         println!("System degraded - Active issues: {}", health.active_issues.len());
    ///         for issue in &health.active_issues {
    ///             println!("  - {}: {}", issue.component, issue.description);
    ///         }
    ///     }
    ///     HealthState::Critical => println!("CRITICAL: System requires immediate attention"),
    ///     HealthState::Offline => println!("System offline"),
    /// }
    ///
    /// // Check component health
    /// for component in &health.component_health {
    ///     if component.error_rate > 0.01 {
    ///         println!("{} has high error rate: {:.2}%",
    ///             component.component_name, component.error_rate * 100.0);
    ///     }
    /// }
    /// # Ok(())
    /// # }
    /// ```
    async fn get_health_status(&self) -> Result<HealthStatus>;

    /// Starts anomaly detection for trading patterns and system behavior
    ///
    /// This method activates anomaly detection algorithms that monitor for unusual
    /// patterns in trading data, latency spikes, volume anomalies, and other
    /// deviations from normal behavior. Multiple algorithms can run concurrently.
    ///
    /// # Arguments
    ///
    /// * `config` - Configuration specifying instruments, algorithms, and sensitivity
    ///
    /// # Returns
    ///
    /// * `Ok(())` - If anomaly detection was successfully started
    /// * `Err` - If configuration is invalid or detection is already running
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use rusty_feeder::provider::ext::{AnomalyConfig, AnomalyAlgorithm};
    /// # use rusty_model::instruments::InstrumentId;
    /// # use rusty_model::venues::Venue;
    /// # async fn example(monitor: &mut impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// let config = AnomalyConfig {
    ///     instruments: vec![
    ///         InstrumentId::new("BTC-USDT", Venue::Binance),
    ///         InstrumentId::new("ETH-USDT", Venue::Binance),
    ///     ],
    ///     sensitivity: 0.8,  // High sensitivity
    ///     window_size_ms: 60_000,  // 1 minute windows
    ///     algorithms: vec![
    ///         AnomalyAlgorithm::StatisticalOutlier {
    ///             threshold_std_dev: 3.0,
    ///         },
    ///         AnomalyAlgorithm::VolumeAnomaly {
    ///             volume_threshold: 5.0,  // 5x normal volume
    ///         },
    ///         AnomalyAlgorithm::LatencyAnomaly {
    ///             latency_threshold_ns: 10_000_000,  // 10ms
    ///         },
    ///     ],
    /// };
    ///
    /// monitor.start_anomaly_detection(config).await?;
    /// # Ok(())
    /// # }
    /// ```
    async fn start_anomaly_detection(&mut self, config: AnomalyConfig) -> Result<()>;

    /// Stops all active anomaly detection algorithms
    ///
    /// This method deactivates all running anomaly detection algorithms and clears
    /// any accumulated detection state.
    ///
    /// # Returns
    ///
    /// * `Ok(())` - If anomaly detection was successfully stopped
    /// * `Err` - If no detection was running
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # async fn example(monitor: &mut impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// // Stop detection during maintenance window
    /// monitor.stop_anomaly_detection().await?;
    /// # Ok(())
    /// # }
    /// ```
    async fn stop_anomaly_detection(&mut self) -> Result<()>;

    /// Retrieves detailed latency distribution statistics for an instrument
    ///
    /// This method provides a comprehensive breakdown of latency measurements including
    /// percentiles (p50, p90, p95, p99, p99.9), maximum values, and histogram buckets.
    /// Useful for identifying latency patterns and optimizing performance.
    ///
    /// # Arguments
    ///
    /// * `instrument_id` - The instrument to analyze
    ///
    /// # Returns
    ///
    /// * `Ok(LatencyDistribution)` - Detailed latency statistics
    /// * `Err` - If instrument is not found or has insufficient data
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use rusty_model::instruments::InstrumentId;
    /// # use rusty_model::venues::Venue;
    /// # async fn example(monitor: &impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// let btc_usdt = InstrumentId::new("BTC-USDT", Venue::Binance);
    /// let latency = monitor.get_latency_distribution(&btc_usdt).await?;
    ///
    /// println!("Latency percentiles for BTC-USDT:");
    /// println!("  P50: {}µs", latency.p50_ns / 1000);
    /// println!("  P90: {}µs", latency.p90_ns / 1000);
    /// println!("  P95: {}µs", latency.p95_ns / 1000);
    /// println!("  P99: {}µs", latency.p99_ns / 1000);
    /// println!("  P99.9: {}µs", latency.p99_9_ns / 1000);
    /// println!("  Max: {}µs", latency.max_ns / 1000);
    ///
    /// // Analyze histogram
    /// for bucket in &latency.histogram {
    ///     println!("  {}µs-{}µs: {} samples",
    ///         bucket.min_ns / 1000, bucket.max_ns / 1000, bucket.count);
    /// }
    /// # Ok(())
    /// # }
    /// ```
    async fn get_latency_distribution(
        &self,
        instrument_id: &InstrumentId,
    ) -> Result<LatencyDistribution>;

    /// Exports all metrics in Prometheus exposition format
    ///
    /// This method generates a text representation of all metrics following the
    /// Prometheus exposition format. The output can be scraped by Prometheus or
    /// compatible monitoring systems. Includes all standard metrics, custom metrics,
    /// and alert states.
    ///
    /// # Returns
    ///
    /// * `Ok(String)` - Prometheus-formatted metrics text
    /// * `Err` - If export fails
    ///
    /// # Output Format
    ///
    /// ```text
    /// # HELP hft_latency_nanoseconds End-to-end latency in nanoseconds
    /// # TYPE hft_latency_nanoseconds histogram
    /// hft_latency_nanoseconds_bucket{exchange="binance",instrument="BTC-USDT",le="1000"} 245
    /// hft_latency_nanoseconds_bucket{exchange="binance",instrument="BTC-USDT",le="5000"} 1823
    /// hft_latency_nanoseconds_sum{exchange="binance",instrument="BTC-USDT"} 4523000
    /// hft_latency_nanoseconds_count{exchange="binance",instrument="BTC-USDT"} 2068
    ///
    /// # HELP hft_messages_total Total messages processed
    /// # TYPE hft_messages_total counter
    /// hft_messages_total{exchange="binance",type="trade"} 150234
    /// hft_messages_total{exchange="binance",type="orderbook"} 892341
    /// ```
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # async fn example(monitor: &impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// let prometheus_data = monitor.export_prometheus_metrics().await?;
    ///
    /// // Write to file for Prometheus to scrape
    /// std::fs::write("/var/lib/prometheus/hft_metrics.prom", prometheus_data)?;
    ///
    /// // Or serve via HTTP endpoint
    /// // warp::reply::with_header(prometheus_data, "Content-Type", "text/plain; version=0.0.4")
    /// # Ok(())
    /// # }
    /// ```
    async fn export_prometheus_metrics(&self) -> Result<String>;

    /// Resets all monitoring statistics to their initial state
    ///
    /// This method clears all accumulated metrics, counters, and statistics while
    /// preserving configuration (alerts, collectors, etc.). Useful for starting
    /// fresh measurements or after system maintenance.
    ///
    /// # Returns
    ///
    /// * `Ok(())` - If statistics were successfully reset
    /// * `Err` - If reset fails
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # async fn example(monitor: &mut impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// // Reset stats at market open
    /// monitor.reset_statistics().await?;
    /// println!("Statistics reset for new trading session");
    /// # Ok(())
    /// # }
    /// ```
    async fn reset_statistics(&mut self) -> Result<()>;

    /// Retrieves advanced trading-specific metrics for an instrument
    ///
    /// This method provides sophisticated trading analytics including order flow
    /// imbalance, VWAP/TWAP calculations, microstructure signals, and execution
    /// quality metrics. These metrics are essential for HFT strategy development
    /// and performance analysis.
    ///
    /// # Arguments
    ///
    /// * `instrument_id` - The instrument to analyze
    ///
    /// # Returns
    ///
    /// * `Ok(TradingMetrics)` - Comprehensive trading analytics
    /// * `Err` - If instrument is not found or has insufficient data
    ///
    /// # Example
    ///
    /// ```rust,no_run
    /// # use rusty_model::instruments::InstrumentId;
    /// # use rusty_model::venues::Venue;
    /// # async fn example(monitor: &impl rusty_feeder::provider::ext::MonitorExt) -> anyhow::Result<()> {
    /// let eth_usdt = InstrumentId::new("ETH-USDT", Venue::Binance);
    /// let trading_metrics = monitor.get_trading_metrics(&eth_usdt).await?;
    ///
    /// // Check microstructure signals
    /// let signals = &trading_metrics.microstructure_signals;
    /// if signals.book_imbalance > 0.7 && signals.momentum > 0.5 {
    ///     println!("Strong bullish signal detected");
    ///     println!("  Book imbalance: {:.3}", signals.book_imbalance);
    ///     println!("  Momentum: {:.3}", signals.momentum);
    ///     println!("  Alpha signal: {:.3}", signals.alpha_signal);
    /// }
    ///
    /// // Analyze execution quality
    /// let exec_quality = &trading_metrics.execution_quality;
    /// println!("Execution metrics:");
    /// println!("  Slippage: {:.2} bps", exec_quality.slippage_bps);
    /// println!("  Market impact: {:.2} bps", exec_quality.market_impact_bps);
    /// println!("  Fill rate: {:.1}%", exec_quality.fill_rate * 100.0);
    ///
    /// // Price analysis
    /// println!("VWAP: {}", trading_metrics.vwap);
    /// println!("TWAP: {}", trading_metrics.twap);
    /// # Ok(())
    /// # }
    /// ```
    async fn get_trading_metrics(&self, instrument_id: &InstrumentId) -> Result<TradingMetrics>;
}

/// Extension trait for new provider implementations
#[async_trait]
pub trait ProviderExt {
    /// Connect to the exchange
    async fn connect(&mut self) -> Result<()>;

    /// Disconnect from the exchange
    async fn disconnect(&mut self) -> Result<()>;

    /// Subscribe to orderbook updates for an instrument
    async fn subscribe_orderbook(
        &mut self,
        instrument_id: &InstrumentId,
        depth: usize,
    ) -> Result<()>;

    /// Subscribe to trade updates for an instrument
    async fn subscribe_trades(&mut self, instrument_id: &InstrumentId) -> Result<()>;

    /// Unsubscribe from orderbook updates
    async fn unsubscribe_orderbook(&mut self, instrument_id: &InstrumentId) -> Result<()>;

    /// Unsubscribe from trade updates
    async fn unsubscribe_trades(&mut self, instrument_id: &InstrumentId) -> Result<()>;

    /// Check if connected
    fn is_connected(&self) -> bool;

    /// Get connection statistics
    fn connection_stats(&self) -> ConnectionStats;

    /// Run the provider with a data handler
    async fn run_with_handler(&mut self, handler: Box<dyn DataHandler + Send + Sync>)
    -> Result<()>;

    /// Fetch available instruments
    async fn fetch_instruments(&self) -> Result<Vec<Box<dyn Instrument>>>;
}

// Note: Since the new provider system doesn't follow the old Provider trait,
// we need manual implementations for each provider type.
// This is actually better for the refactoring - we can have explicit control.

/// Unified provider interface for the monitor system
pub enum UnifiedProvider {
    /// Binance futures market provider
    BinanceFutures(Box<BinanceFuturesProvider>),
    // Add other providers as they're migrated to the new system
}

impl UnifiedProvider {
    /// Create a new provider based on exchange name
    pub fn new(exchange_name: &str) -> Result<Self> {
        match exchange_name.to_lowercase().as_str() {
            "binance" | "binance_futures" => {
                use crate::ConnectionConfig;
                let provider = BinanceFuturesProvider::new(
                    ConnectionConfig::default(),
                    BinanceFuturesMarketType::UsdM,
                );
                Ok(Self::BinanceFutures(Box::new(provider)))
            }
            _ => Err(anyhow::anyhow!("Unsupported exchange: {}", exchange_name)),
        }
    }

    /// Get the exchange name
    pub fn name(&self) -> &str {
        match self {
            Self::BinanceFutures(p) => p.name(),
        }
    }
}

#[async_trait]
impl ProviderExt for UnifiedProvider {
    async fn connect(&mut self) -> Result<()> {
        match self {
            Self::BinanceFutures(p) => p.connect().await,
        }
    }

    async fn disconnect(&mut self) -> Result<()> {
        match self {
            Self::BinanceFutures(p) => p.disconnect().await,
        }
    }

    async fn subscribe_orderbook(
        &mut self,
        instrument_id: &InstrumentId,
        depth: usize,
    ) -> Result<()> {
        match self {
            Self::BinanceFutures(p) => p.subscribe_orderbook(instrument_id, depth).await,
        }
    }

    async fn subscribe_trades(&mut self, instrument_id: &InstrumentId) -> Result<()> {
        match self {
            Self::BinanceFutures(p) => p.subscribe_trades(instrument_id).await,
        }
    }

    async fn unsubscribe_orderbook(&mut self, instrument_id: &InstrumentId) -> Result<()> {
        match self {
            Self::BinanceFutures(p) => p.unsubscribe_orderbook(instrument_id).await,
        }
    }

    async fn unsubscribe_trades(&mut self, instrument_id: &InstrumentId) -> Result<()> {
        match self {
            Self::BinanceFutures(p) => p.unsubscribe_trades(instrument_id).await,
        }
    }

    fn is_connected(&self) -> bool {
        match self {
            Self::BinanceFutures(p) => p.is_connected(),
        }
    }

    fn connection_stats(&self) -> ConnectionStats {
        match self {
            Self::BinanceFutures(p) => p.connection_stats(),
        }
    }

    async fn run_with_handler(
        &mut self,
        handler: Box<dyn DataHandler + Send + Sync>,
    ) -> Result<()> {
        match self {
            Self::BinanceFutures(p) => p.run_with_handler(handler).await,
        }
    }

    async fn fetch_instruments(&self) -> Result<Vec<Box<dyn Instrument>>> {
        match self {
            Self::BinanceFutures(p) => p.fetch_instruments().await,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::provider::connection::ConnectionState;
    use anyhow::Result;
    use async_trait::async_trait;
    use parking_lot::RwLock;
    use quanta::Clock;
    use rust_decimal::Decimal;
    use rustc_hash::FxHashMap;
    use rusty_model::venues::Venue;
    use std::sync::Arc;
    use std::sync::atomic::{AtomicBool, AtomicU64, Ordering};

    /// Test implementation of MonitorExt for unit testing
    struct TestMonitor {
        /// Simulated metrics data for testing
        instrument_metrics: Arc<RwLock<FxHashMap<InstrumentId, InstrumentMetrics>>>,
        /// Track enabled alerts
        alerts: Arc<RwLock<FxHashMap<AlertHandle, AlertConfig>>>,
        /// Next alert handle ID
        next_alert_id: AtomicU64,
        /// Track registered metrics collectors
        collectors: Arc<RwLock<Vec<Box<dyn MetricsCollector>>>>,
        /// Track if anomaly detection is active
        anomaly_detection_active: AtomicBool,
        /// Track anomaly config
        anomaly_config: Arc<RwLock<Option<AnomalyConfig>>>,
        /// Health state for testing
        health_state: Arc<RwLock<HealthState>>,
        /// Connection errors for testing
        connection_errors: AtomicU64,
        /// Clock for consistent time
        clock: Clock,
        /// Simulated stats that can be reset
        stats: Arc<RwLock<TestStats>>,
    }

    #[derive(Default)]
    struct TestStats {
        messages_received: u64,
        messages_dropped: u64,
        total_latency_ns: u64,
        latency_samples: u64,
    }

    impl TestMonitor {
        fn new() -> Self {
            let clock = Clock::new();

            // Create default metrics for testing
            let mut metrics_map = FxHashMap::default();

            // Add sample BTC-USDT metrics
            let btc_usdt = InstrumentId::new("BTC-USDT", Venue::Binance);
            metrics_map.insert(
                btc_usdt.clone(),
                Self::create_sample_metrics(btc_usdt, &clock),
            );

            // Add sample ETH-USDT metrics
            let eth_usdt = InstrumentId::new("ETH-USDT", Venue::Binance);
            metrics_map.insert(
                eth_usdt.clone(),
                Self::create_sample_metrics(eth_usdt, &clock),
            );

            Self {
                instrument_metrics: Arc::new(RwLock::new(metrics_map)),
                alerts: Arc::new(RwLock::new(FxHashMap::default())),
                next_alert_id: AtomicU64::new(1),
                collectors: Arc::new(RwLock::new(Vec::new())),
                anomaly_detection_active: AtomicBool::new(false),
                anomaly_config: Arc::new(RwLock::new(None)),
                health_state: Arc::new(RwLock::new(HealthState::Healthy)),
                connection_errors: AtomicU64::new(0),
                clock,
                stats: Arc::new(RwLock::new(TestStats::default())),
            }
        }

        fn create_sample_metrics(instrument_id: InstrumentId, clock: &Clock) -> InstrumentMetrics {
            use crate::feeder::FeedStats;

            InstrumentMetrics {
                instrument_id,
                feed_stats: {
                    let mut stats = FeedStats::default();
                    stats.messages_processed = 10000;
                    stats.messages_per_second = 150.0;
                    stats.avg_process_latency_ns = 500_000; // 0.5ms
                    stats.max_process_latency_ns = 2_000_000; // 2ms
                    stats.p99_process_latency_ns = 1_500_000; // 1.5ms
                    stats.dropped_messages = 5;
                    stats.last_update_time = clock.raw();
                    stats.memory_usage_bytes = 1024 * 1024; // 1MB
                    stats
                },
                connection_stats: ConnectionStats {
                    messages_received: 10000,
                    messages_sent: 0,
                    reconnections: 0,
                    bytes_received: 1_000_000,
                    bytes_sent: 0,
                    last_message_time: clock.raw() - 100_000_000, // 100ms ago
                    last_ping_time: clock.raw() - 30_000_000_000, // 30s ago
                    last_pong_time: clock.raw() - 30_000_000_000, // 30s ago
                    avg_latency_ns: 1_000_000,                    // 1ms
                    connected_time: clock.raw() - 3_600_000_000_000, // 1 hour ago
                    connection_state: ConnectionState::Connected,
                    errors: 0,
                },
                order_flow_metrics: OrderFlowMetrics {
                    volume_imbalance: 0.15,
                    book_pressure: 1.2,
                    trade_intensity: 25.5,
                    avg_trade_size: Decimal::new(1500, 2), // 15.00
                    price_volatility: 0.02,
                    avg_spread_bps: 2.5,
                    max_spread_bps: 10.0,
                    market_impact_bps: 0.5,
                },
                latency_metrics: LatencyMetrics {
                    network_latency_ns: 800_000,    // 0.8ms
                    parsing_latency_ns: 100_000,    // 0.1ms
                    processing_latency_ns: 100_000, // 0.1ms
                    total_latency_ns: 1_000_000,    // 1ms
                    latency_jitter_ns: 200_000,     // 0.2ms
                },
                anomaly_score: 0.05,
                health_score: 0.95,
                last_updated: clock.raw(),
            }
        }

        fn simulate_degraded_health(&self) {
            *self.health_state.write() = HealthState::Degraded;
            self.connection_errors.store(100, Ordering::SeqCst);
        }

        fn simulate_high_latency(&self, instrument_id: &InstrumentId) {
            let mut metrics = self.instrument_metrics.write();
            if let Some(m) = metrics.get_mut(instrument_id) {
                m.latency_metrics.total_latency_ns = 10_000_000; // 10ms
                m.latency_metrics.network_latency_ns = 8_000_000; // 8ms
                m.health_score = 0.7;
                m.anomaly_score = 0.8;
            }
        }
    }

    #[async_trait]
    impl MonitorExt for TestMonitor {
        async fn get_instrument_metrics(
            &self,
            instrument_id: &InstrumentId,
        ) -> Result<InstrumentMetrics> {
            self.instrument_metrics
                .read()
                .get(instrument_id)
                .cloned()
                .ok_or_else(|| anyhow::anyhow!("Instrument {} not found", instrument_id))
        }

        async fn get_aggregated_metrics(&self) -> Result<AggregatedMetrics> {
            let metrics = self.instrument_metrics.read();
            let stats = self.stats.read();

            let total_messages: u64 = metrics
                .values()
                .map(|m| m.feed_stats.messages_processed)
                .sum();

            let total_dropped: u64 = metrics
                .values()
                .map(|m| m.feed_stats.dropped_messages)
                .sum();

            let avg_latency = if stats.latency_samples > 0 {
                stats.total_latency_ns / stats.latency_samples
            } else {
                metrics
                    .values()
                    .map(|m| m.latency_metrics.total_latency_ns)
                    .sum::<u64>()
                    / metrics.len().max(1) as u64
            };

            let max_latency = metrics
                .values()
                .map(|m| m.latency_metrics.total_latency_ns)
                .max()
                .unwrap_or(0);

            let p99_latency = metrics
                .values()
                .map(|m| m.feed_stats.p99_process_latency_ns)
                .max()
                .unwrap_or(0);

            let overall_health =
                metrics.values().map(|m| m.health_score).sum::<f64>() / metrics.len().max(1) as f64;

            Ok(AggregatedMetrics {
                total_instruments: metrics.len(),
                total_messages_processed: total_messages,
                total_dropped_messages: total_dropped,
                avg_latency_ns: avg_latency,
                max_latency_ns: max_latency,
                p99_latency_ns: p99_latency,
                total_memory_usage_bytes: metrics
                    .values()
                    .map(|m| m.feed_stats.memory_usage_bytes)
                    .sum(),
                total_errors: self.connection_errors.load(Ordering::SeqCst) as u32,
                overall_health_score: overall_health,
                active_alerts: self.alerts.read().len() as u32,
                timestamp: self.clock.raw(),
            })
        }

        async fn register_metrics_collector(
            &mut self,
            collector: Box<dyn MetricsCollector>,
        ) -> Result<()> {
            let mut collectors = self.collectors.write();

            // Check for duplicate names
            let new_name = collector.name();
            if collectors.iter().any(|c| c.name() == new_name) {
                return Err(anyhow::anyhow!(
                    "Collector '{}' already registered",
                    new_name
                ));
            }

            collectors.push(collector);
            Ok(())
        }

        async fn enable_alert(&mut self, alert_config: AlertConfig) -> Result<AlertHandle> {
            if !alert_config.enabled {
                return Err(anyhow::anyhow!(
                    "Cannot enable a disabled alert configuration"
                ));
            }

            if alert_config.threshold < 0.0
                && !matches!(
                    alert_config.condition,
                    AlertCondition::ConnectionLoss { .. }
                )
            {
                return Err(anyhow::anyhow!(
                    "Invalid threshold: {} (must be non-negative)",
                    alert_config.threshold
                ));
            }

            let handle = AlertHandle(self.next_alert_id.fetch_add(1, Ordering::SeqCst));
            self.alerts.write().insert(handle, alert_config);
            Ok(handle)
        }

        async fn disable_alert(&mut self, handle: AlertHandle) -> Result<()> {
            self.alerts
                .write()
                .remove(&handle)
                .ok_or_else(|| anyhow::anyhow!("Alert handle {:?} not found", handle))
                .map(|_| ())
        }

        async fn get_health_status(&self) -> Result<HealthStatus> {
            let health_state = self.health_state.read().clone();
            let metrics = self.instrument_metrics.read();
            let errors = self.connection_errors.load(Ordering::SeqCst);

            let mut component_health = vec![];
            let mut active_issues = vec![];

            // Check WebSocket health
            let ws_health = if errors == 0 {
                HealthState::Healthy
            } else if errors < 10 {
                HealthState::Degraded
            } else {
                HealthState::Critical
            };

            component_health.push(ComponentHealth {
                component_name: "WebSocket Connection".to_string(),
                status: ws_health.clone(),
                last_heartbeat: self.clock.raw() - 1_000_000_000, // 1 second ago
                error_rate: errors as f64 / 1000.0,
                latency_p99_ns: 2_000_000, // 2ms
            });

            // Add data parser health
            component_health.push(ComponentHealth {
                component_name: "Data Parser".to_string(),
                status: HealthState::Healthy,
                last_heartbeat: self.clock.raw() - 500_000_000, // 0.5 seconds ago
                error_rate: 0.001,
                latency_p99_ns: 100_000, // 0.1ms
            });

            // Check for issues
            if matches!(ws_health, HealthState::Critical) {
                active_issues.push(HealthIssue {
                    severity: IssueSeverity::Critical,
                    component: "WebSocket Connection".to_string(),
                    description: "High error rate detected".to_string(),
                    first_seen: self.clock.raw() - 300_000_000_000, // 5 minutes ago
                    last_seen: self.clock.raw(),
                    count: errors as u32,
                });
            }

            // Check for high latency issues
            for (instrument_id, metrics) in metrics.iter() {
                if metrics.latency_metrics.total_latency_ns > 5_000_000 {
                    // 5ms
                    active_issues.push(HealthIssue {
                        severity: IssueSeverity::Warning,
                        component: format!("{instrument_id} Feed"),
                        description: format!(
                            "High latency: {}ms",
                            metrics.latency_metrics.total_latency_ns / 1_000_000
                        ),
                        first_seen: self.clock.raw() - 60_000_000_000, // 1 minute ago
                        last_seen: self.clock.raw(),
                        count: 1,
                    });
                }
            }

            let performance_grade = match health_state {
                HealthState::Healthy => 'A',
                HealthState::Degraded => 'B',
                HealthState::Critical => 'D',
                HealthState::Offline => 'F',
            };

            Ok(HealthStatus {
                overall_status: health_state,
                component_health,
                active_issues,
                performance_grade,
                uptime_seconds: 3600, // 1 hour for testing
                last_check_time: self.clock.raw(),
            })
        }

        async fn start_anomaly_detection(&mut self, config: AnomalyConfig) -> Result<()> {
            if self.anomaly_detection_active.load(Ordering::SeqCst) {
                return Err(anyhow::anyhow!("Anomaly detection is already running"));
            }

            if config.instruments.is_empty() {
                return Err(anyhow::anyhow!(
                    "No instruments specified for anomaly detection"
                ));
            }

            if config.sensitivity < 0.0 || config.sensitivity > 1.0 {
                return Err(anyhow::anyhow!("Sensitivity must be between 0.0 and 1.0"));
            }

            *self.anomaly_config.write() = Some(config);
            self.anomaly_detection_active.store(true, Ordering::SeqCst);
            Ok(())
        }

        async fn stop_anomaly_detection(&mut self) -> Result<()> {
            if !self.anomaly_detection_active.load(Ordering::SeqCst) {
                return Err(anyhow::anyhow!("Anomaly detection is not running"));
            }

            self.anomaly_detection_active.store(false, Ordering::SeqCst);
            *self.anomaly_config.write() = None;
            Ok(())
        }

        async fn get_latency_distribution(
            &self,
            instrument_id: &InstrumentId,
        ) -> Result<LatencyDistribution> {
            let metrics = self.instrument_metrics.read();
            let instrument_metrics = metrics
                .get(instrument_id)
                .ok_or_else(|| anyhow::anyhow!("Instrument {} not found", instrument_id))?;

            let base_latency = instrument_metrics.latency_metrics.total_latency_ns;

            // Create realistic distribution based on base latency
            let histogram = vec![
                LatencyBucket {
                    min_ns: 0,
                    max_ns: base_latency / 2,
                    count: 100,
                },
                LatencyBucket {
                    min_ns: base_latency / 2,
                    max_ns: base_latency,
                    count: 500,
                },
                LatencyBucket {
                    min_ns: base_latency,
                    max_ns: base_latency * 2,
                    count: 300,
                },
                LatencyBucket {
                    min_ns: base_latency * 2,
                    max_ns: base_latency * 5,
                    count: 90,
                },
                LatencyBucket {
                    min_ns: base_latency * 5,
                    max_ns: base_latency * 10,
                    count: 10,
                },
            ];

            Ok(LatencyDistribution {
                p50_ns: base_latency,
                p90_ns: base_latency * 2,
                p95_ns: (base_latency as f64 * 2.5) as u64,
                p99_ns: base_latency * 5,
                p99_9_ns: base_latency * 8,
                max_ns: base_latency * 10,
                histogram,
            })
        }

        async fn export_prometheus_metrics(&self) -> Result<String> {
            let aggregated = self.get_aggregated_metrics().await?;
            let metrics = self.instrument_metrics.read();
            let alerts = self.alerts.read();

            let mut output = String::new();

            // System-wide metrics
            output.push_str("# HELP hft_instruments_total Total number of monitored instruments\n");
            output.push_str("# TYPE hft_instruments_total gauge\n");
            output.push_str(&format!(
                "hft_instruments_total {}\n\n",
                aggregated.total_instruments
            ));

            output.push_str("# HELP hft_messages_processed_total Total messages processed\n");
            output.push_str("# TYPE hft_messages_processed_total counter\n");
            output.push_str(&format!(
                "hft_messages_processed_total {}\n\n",
                aggregated.total_messages_processed
            ));

            output.push_str("# HELP hft_messages_dropped_total Total messages dropped\n");
            output.push_str("# TYPE hft_messages_dropped_total counter\n");
            output.push_str(&format!(
                "hft_messages_dropped_total {}\n\n",
                aggregated.total_dropped_messages
            ));

            output.push_str("# HELP hft_latency_nanoseconds End-to-end latency in nanoseconds\n");
            output.push_str("# TYPE hft_latency_nanoseconds histogram\n");

            // Per-instrument metrics
            for (instrument_id, m) in metrics.iter() {
                let labels = format!(
                    "exchange=\"{}\",instrument=\"{}\"",
                    instrument_id.venue.to_str(),
                    instrument_id.symbol
                );

                // Latency histogram
                output.push_str(&format!(
                    "hft_latency_nanoseconds_bucket{{{}le=\"1000000\"}} {}\n",
                    labels,
                    if m.latency_metrics.total_latency_ns <= 1_000_000 {
                        1000
                    } else {
                        0
                    }
                ));
                output.push_str(&format!(
                    "hft_latency_nanoseconds_bucket{{{}le=\"5000000\"}} {}\n",
                    labels,
                    if m.latency_metrics.total_latency_ns <= 5_000_000 {
                        1000
                    } else {
                        500
                    }
                ));
                output.push_str(&format!(
                    "hft_latency_nanoseconds_bucket{{{labels}le=\"+Inf\"}} 1000\n"
                ));
                output.push_str(&format!(
                    "hft_latency_nanoseconds_sum{{{}}} {}\n",
                    labels,
                    m.latency_metrics.total_latency_ns * 1000 // Total across samples
                ));
                output.push_str(&format!(
                    "hft_latency_nanoseconds_count{{{labels}}} 1000\n\n"
                ));

                // Health score
                output.push_str(&format!(
                    "hft_health_score{{{}}} {}\n",
                    labels, m.health_score
                ));

                // Anomaly score
                output.push_str(&format!(
                    "hft_anomaly_score{{{}}} {}\n",
                    labels, m.anomaly_score
                ));
            }

            // Active alerts
            output.push_str("\n# HELP hft_alerts_active Number of active alerts\n");
            output.push_str("# TYPE hft_alerts_active gauge\n");
            output.push_str(&format!("hft_alerts_active {}\n", alerts.len()));

            Ok(output)
        }

        async fn reset_statistics(&mut self) -> Result<()> {
            // Reset stats
            *self.stats.write() = TestStats::default();

            // Reset error counter
            self.connection_errors.store(0, Ordering::SeqCst);

            // Reset metrics to baseline
            let mut metrics = self.instrument_metrics.write();
            for (instrument_id, metric) in metrics.iter_mut() {
                *metric = Self::create_sample_metrics(instrument_id.clone(), &self.clock);
            }

            Ok(())
        }

        async fn get_trading_metrics(
            &self,
            instrument_id: &InstrumentId,
        ) -> Result<TradingMetrics> {
            let metrics = self.instrument_metrics.read();
            let _ = metrics
                .get(instrument_id)
                .ok_or_else(|| anyhow::anyhow!("Instrument {} not found", instrument_id))?;

            Ok(TradingMetrics {
                order_flow_imbalance: 0.25,
                vwap: Decimal::new(4523450, 2), // 45234.50
                twap: Decimal::new(4520000, 2), // 45200.00
                microstructure_signals: MicrostructureSignals {
                    book_imbalance: 0.15,
                    trade_sign_accuracy: 0.72,
                    alpha_signal: 0.08,
                    momentum: 0.35,
                    mean_reversion: 0.20,
                },
                execution_quality: ExecutionQualityMetrics {
                    slippage_bps: 1.5,
                    market_impact_bps: 0.8,
                    fill_rate: 0.95,
                    avg_fill_time_ns: 2_500_000, // 2.5ms
                    implementation_shortfall_bps: 2.3,
                },
            })
        }
    }

    // Custom test metrics collector
    struct TestMetricsCollector {
        name: String,
        metrics_to_return: Vec<CustomMetric>,
    }

    #[async_trait]
    impl MetricsCollector for TestMetricsCollector {
        async fn collect(&self) -> Result<Vec<CustomMetric>> {
            Ok(self.metrics_to_return.clone())
        }

        fn name(&self) -> &str {
            &self.name
        }
    }

    // Tests start here

    #[tokio::test]
    async fn test_get_instrument_metrics_success() {
        let monitor = TestMonitor::new();
        let btc_usdt = InstrumentId::new("BTC-USDT", Venue::Binance);

        let metrics = monitor.get_instrument_metrics(&btc_usdt).await.unwrap();

        assert_eq!(metrics.instrument_id, btc_usdt);
        assert_eq!(metrics.feed_stats.messages_processed, 10000);
        assert_eq!(metrics.latency_metrics.total_latency_ns, 1_000_000);
        assert_eq!(metrics.order_flow_metrics.avg_spread_bps, 2.5);
        assert_eq!(metrics.health_score, 0.95);
    }

    #[tokio::test]
    async fn test_get_instrument_metrics_not_found() {
        let monitor = TestMonitor::new();
        let unknown = InstrumentId::new("UNKNOWN-USDT", Venue::Binance);

        let result = monitor.get_instrument_metrics(&unknown).await;

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

    #[tokio::test]
    async fn test_export_prometheus_metrics() {
        let monitor = TestMonitor::new();

        let prometheus_output = monitor.export_prometheus_metrics().await.unwrap();

        // Check for required metric types
        assert!(prometheus_output.contains("# HELP hft_instruments_total"));
        assert!(prometheus_output.contains("# TYPE hft_instruments_total gauge"));
        assert!(prometheus_output.contains("hft_instruments_total 2"));

        assert!(prometheus_output.contains("# HELP hft_messages_processed_total"));
        assert!(prometheus_output.contains("# TYPE hft_messages_processed_total counter"));

        assert!(prometheus_output.contains("# HELP hft_latency_nanoseconds"));
        assert!(prometheus_output.contains("# TYPE hft_latency_nanoseconds histogram"));

        // Check for instrument-specific metrics - fixed to match actual format
        assert!(prometheus_output.contains("exchange=\"Binance\",instrument=\"BTC-USDT\""));
        assert!(prometheus_output.contains("hft_latency_nanoseconds_bucket"));
        assert!(prometheus_output.contains("hft_health_score"));
        assert!(prometheus_output.contains("hft_anomaly_score"));

        // Check for alerts metric
        assert!(prometheus_output.contains("# HELP hft_alerts_active"));
        assert!(prometheus_output.contains("hft_alerts_active 0"));
    }

    #[tokio::test]
    async fn test_get_health_status_healthy() {
        let monitor = TestMonitor::new();

        let health = monitor.get_health_status().await.unwrap();

        assert_eq!(health.overall_status, HealthState::Healthy);
        assert_eq!(health.performance_grade, 'A');
        assert!(health.active_issues.is_empty());
        assert_eq!(health.component_health.len(), 2);

        let ws_health = &health.component_health[0];
        assert_eq!(ws_health.component_name, "WebSocket Connection");
        assert_eq!(ws_health.status, HealthState::Healthy);
        assert_eq!(ws_health.error_rate, 0.0);
    }

    #[tokio::test]
    async fn test_get_health_status_degraded() {
        let monitor = TestMonitor::new();
        monitor.simulate_degraded_health();

        let health = monitor.get_health_status().await.unwrap();

        assert_eq!(health.overall_status, HealthState::Degraded);
        assert_eq!(health.performance_grade, 'B');
        assert!(!health.active_issues.is_empty());

        let issue = &health.active_issues[0];
        assert_eq!(issue.severity, IssueSeverity::Critical);
        assert!(issue.description.contains("High error rate"));
    }

    #[tokio::test]
    async fn test_get_health_status_with_high_latency() {
        let monitor = TestMonitor::new();
        let btc_usdt = InstrumentId::new("BTC-USDT", Venue::Binance);
        monitor.simulate_high_latency(&btc_usdt);

        let health = monitor.get_health_status().await.unwrap();

        // Should have a latency warning
        let latency_issues: Vec<_> = health
            .active_issues
            .iter()
            .filter(|i| i.description.contains("High latency"))
            .collect();

        assert_eq!(latency_issues.len(), 1);
        assert_eq!(latency_issues[0].severity, IssueSeverity::Warning);
        assert!(latency_issues[0].component.contains("BTC-USDT"));
    }

    #[tokio::test]
    async fn test_enable_alert_success() {
        let mut monitor = TestMonitor::new();

        let alert_config = AlertConfig {
            name: "Test Alert".to_string(),
            condition: AlertCondition::LatencyThreshold {
                instrument_id: None,
            },
            threshold: 5_000_000.0, // 5ms
            duration_ms: 1000,
            severity: IssueSeverity::Warning,
            enabled: true,
        };

        let handle = monitor.enable_alert(alert_config.clone()).await.unwrap();

        assert_eq!(handle.0, 1);
        assert_eq!(monitor.alerts.read().len(), 1);
        assert_eq!(
            monitor.alerts.read().get(&handle).unwrap().name,
            "Test Alert"
        );
    }
}