Rust for High-Frequency Trading: Microsecond Latency with Memory Safety

use std::sync::atomic::{AtomicU64, AtomicPtr, Ordering};
use std::ptr;
use std::collections::BTreeMap;

/// Ultra-fast order book with lock-free price level updates
#[repr(align(64))] // Cache-line alignment for performance
pub struct OrderBook {
    /// Sequence number for ordering updates
    sequence: AtomicU64,
    
    /// Best bid price (atomic for lock-free reads)
    best_bid: AtomicU64,
    
    /// Best ask price (atomic for lock-free reads)  
    best_ask: AtomicU64,
    
    /// Total bid volume at best price
    bid_volume: AtomicU64,
    
    /// Total ask volume at best price
    ask_volume: AtomicU64,
    
    /// Price levels using lock-free operations
    price_levels: AtomicPtr<PriceLevels>,
}

#[derive(Clone)]
struct PriceLevel {
    price: u64,      // Price in fixed-point (price * 10000)
    volume: u64,     // Total volume at this price
    order_count: u32, // Number of orders at this level
    timestamp: u64,   // Nanosecond timestamp
}

impl OrderBook {
    pub fn new() -> Self {
        Self {
            sequence: AtomicU64::new(0),
            best_bid: AtomicU64::new(0),
            best_ask: AtomicU64::new(u64::MAX),
            bid_volume: AtomicU64::new(0),
            ask_volume: AtomicU64::new(0),
            price_levels: AtomicPtr::new(Box::into_raw(Box::new(PriceLevels::new()))),
        }
    }

    /// Add order with sub-microsecond latency
    #[inline(always)]
    pub fn add_order(&self, side: Side, price: u64, volume: u64) -> u64 {
        let seq = self.sequence.fetch_add(1, Ordering::Relaxed);
        let timestamp = get_timestamp_nanos();
        
        // Lock-free update using compare-and-swap
        match side {
            Side::Bid => {
                // Update best bid if this price is better
                let current_best = self.best_bid.load(Ordering::Acquire);
                if price > current_best {
                    let _ = self.best_bid.compare_exchange_weak(
                        current_best, 
                        price, 
                        Ordering::Release, 
                        Ordering::Relaxed
                    );
                    self.bid_volume.store(volume, Ordering::Release);
                }
            }
            Side::Ask => {
                // Update best ask if this price is better  
                let current_best = self.best_ask.load(Ordering::Acquire);
                if price < current_best {
                    let _ = self.best_ask.compare_exchange_weak(
                        current_best,
                        price,
                        Ordering::Release,
                        Ordering::Relaxed
                    );
                    self.ask_volume.store(volume, Ordering::Release);
                }
            }
        }
        
        // Update price levels (lock-free using hazard pointers)
        self.update_price_level(side, price, volume, timestamp);
        
        seq
    }

    /// Get top-of-book with zero allocation
    #[inline(always)]
    pub fn get_top_of_book(&self) -> TopOfBook {
        TopOfBook {
            bid_price: self.best_bid.load(Ordering::Acquire),
            ask_price: self.best_ask.load(Ordering::Acquire),
            bid_volume: self.bid_volume.load(Ordering::Acquire),
            ask_volume: self.ask_volume.load(Ordering::Acquire),
            sequence: self.sequence.load(Ordering::Acquire),
        }
    }

    /// Execute market order against the book
    #[inline(always)]  
    pub fn execute_market_order(&self, side: Side, volume: u64) -> ExecutionResult {
        let start_time = get_timestamp_nanos();
        
        let (execution_price, executed_volume) = match side {
            Side::Buy => {
                let ask_price = self.best_ask.load(Ordering::Acquire);
                let ask_volume = self.ask_volume.load(Ordering::Acquire);
                
                let exec_vol = volume.min(ask_volume);
                (ask_price, exec_vol)
            }
            Side::Sell => {
                let bid_price = self.best_bid.load(Ordering::Acquire);
                let bid_volume = self.bid_volume.load(Ordering::Acquire);
                
                let exec_vol = volume.min(bid_volume);
                (bid_price, exec_vol)
            }
        };
        
        let latency_nanos = get_timestamp_nanos() - start_time;
        
        ExecutionResult {
            price: execution_price,
            volume: executed_volume,
            latency_nanos,
            sequence: self.sequence.fetch_add(1, Ordering::Relaxed),
        }
    }
}

#[derive(Debug, Clone, Copy)]
pub enum Side {
    Bid,
    Ask,
    Buy,  // Market buy
    Sell, // Market sell
}

#[derive(Debug, Clone, Copy)]
pub struct TopOfBook {
    pub bid_price: u64,
    pub ask_price: u64,
    pub bid_volume: u64,
    pub ask_volume: u64,
    pub sequence: u64,
}

#[derive(Debug)]
pub struct ExecutionResult {
    pub price: u64,
    pub volume: u64,
    pub latency_nanos: u64,
    pub sequence: u64,
}

/// Get nanosecond timestamp with minimal overhead
#[inline(always)]
fn get_timestamp_nanos() -> u64 {
    unsafe {
        let mut ts: libc::timespec = std::mem::zeroed();
        libc::clock_gettime(libc::CLOCK_MONOTONIC_RAW, &mut ts);
        (ts.tv_sec as u64) * 1_000_000_000 + (ts.tv_nsec as u64)
    }
}

use std::mem::MaybeUninit;
use std::slice;

/// High-performance market data processor with zero allocations
pub struct MarketDataProcessor {
    /// Ring buffer for incoming messages (no heap allocation)
    message_buffer: [MaybeUninit<MarketDataMessage>; 65536],
    read_index: usize,
    write_index: usize,
    
    /// Statistics tracking  
    messages_processed: u64,
    total_latency_nanos: u64,
    
    /// Symbol lookup table (compile-time generated)
    symbol_map: &'static phf::Map<&'static str, u16>,
}

#[repr(C, packed)]
#[derive(Clone, Copy)]
pub struct MarketDataMessage {
    pub symbol_id: u16,
    pub message_type: u8,
    pub side: u8,
    pub price: u64,        // Fixed-point: actual_price * 10000
    pub volume: u64,
    pub timestamp: u64,    // Nanoseconds since epoch
    pub sequence: u64,
}

impl MarketDataProcessor {
    /// Process market data with zero heap allocations
    #[inline(always)]
    pub fn process_messages(&mut self, raw_data: &[u8]) -> u32 {
        let mut processed = 0u32;
        let mut offset = 0;
        
        // Process multiple messages in a tight loop
        while offset + 40 <= raw_data.len() {
            let start_time = get_timestamp_nanos();
            
            // Zero-copy message parsing
            let message = unsafe {
                // Safe: we've verified buffer bounds above
                let ptr = raw_data.as_ptr().add(offset) as *const MarketDataMessage;
                ptr.read_unaligned()
            };
            
            // Validate message integrity
            if self.is_valid_message(&message) {
                // Update order book (lock-free)
                self.apply_market_data_update(message);
                processed += 1;
            }
            
            let latency = get_timestamp_nanos() - start_time;
            self.total_latency_nanos += latency;
            self.messages_processed += 1;
            
            offset += 40; // Fixed message size
        }
        
        processed
    }
    
    /// Apply market data update with minimal branching
    #[inline(always)]
    fn apply_market_data_update(&mut self, msg: MarketDataMessage) {
        match msg.message_type {
            // Add order
            1 => {
                let side = if msg.side == 0 { Side::Bid } else { Side::Ask };
                ORDER_BOOKS[msg.symbol_id as usize].add_order(side, msg.price, msg.volume);
            }
            // Cancel order  
            2 => {
                ORDER_BOOKS[msg.symbol_id as usize].cancel_order(msg.sequence);
            }
            // Modify order
            3 => {
                let side = if msg.side == 0 { Side::Bid } else { Side::Ask };
                ORDER_BOOKS[msg.symbol_id as usize].modify_order(msg.sequence, msg.price, msg.volume);
            }
            // Trade execution
            4 => {
                ORDER_BOOKS[msg.symbol_id as usize].record_trade(msg.price, msg.volume, msg.timestamp);
            }
            _ => {} // Unknown message type - ignore
        }
    }
    
    /// Validate message with branch-free checks where possible
    #[inline(always)]
    fn is_valid_message(&self, msg: &MarketDataMessage) -> bool {
        // Use bitwise operations for faster validation
        let symbol_valid = msg.symbol_id < MAX_SYMBOLS;
        let type_valid = msg.message_type <= 4;
        let side_valid = msg.side <= 1;
        let price_valid = msg.price > 0 && msg.price < 1_000_000_0000; // Max $100k
        
        symbol_valid & type_valid & side_valid & price_valid
    }
    
    /// Get processing statistics
    pub fn get_stats(&self) -> ProcessingStats {
        ProcessingStats {
            messages_processed: self.messages_processed,
            average_latency_nanos: if self.messages_processed > 0 {
                self.total_latency_nanos / self.messages_processed
            } else {
                0
            },
            throughput_msg_per_sec: self.calculate_throughput(),
        }
    }
}

// Global order book array for maximum performance (avoiding hash lookups)
static mut ORDER_BOOKS: [OrderBook; 4096] = [const { OrderBook::new() }; 4096];

const MAX_SYMBOLS: u16 = 4096;

#[derive(Debug)]
pub struct ProcessingStats {
    pub messages_processed: u64,
    pub average_latency_nanos: u64,
    pub throughput_msg_per_sec: f64,
}

/// Optimized symbol lookup using perfect hash functions (compile-time generated)
pub mod symbol_lookup {
    use phf::phf_map;
    
    pub static SYMBOL_TO_ID: phf::Map<&'static str, u16> = phf_map! {
        "AAPL" => 0,
        "MSFT" => 1,
        "GOOGL" => 2,
        "TSLA" => 3,
        // ... thousands more symbols
    };
    
    #[inline(always)]
    pub fn get_symbol_id(symbol: &str) -> Option<u16> {
        SYMBOL_TO_ID.get(symbol).copied()
    }
}

/// High-performance market making strategy with built-in risk controls
pub struct MarketMaker {
    /// Strategy parameters (compile-time validated)
    params: MarketMakingParams,
    
    /// Current positions by symbol
    positions: [AtomicI64; 4096], // Signed for long/short positions
    
    /// PnL tracking (in cents to avoid floating point)
    unrealized_pnl_cents: AtomicI64,
    realized_pnl_cents: AtomicI64,
    
    /// Risk limits
    max_position_size: u64,
    max_loss_cents: i64,
    
    /// Performance metrics
    orders_sent: AtomicU64,
    fills_received: AtomicU64,
    
    /// Quote generation state
    last_quote_time: AtomicU64,
    quote_sequence: AtomicU64,
}

#[derive(Debug, Clone, Copy)]
pub struct MarketMakingParams {
    pub spread_bps: u16,           // Spread in basis points
    pub quote_size: u64,           // Standard quote size
    pub max_inventory: u64,        // Maximum inventory position
    pub skew_factor: f32,          // Inventory skew adjustment
    pub min_edge_bps: u16,         // Minimum edge requirement
    pub quote_refresh_nanos: u64,  // Minimum time between quotes
}

#[derive(Debug)]
pub struct QuoteUpdate {
    pub symbol_id: u16,
    pub bid_price: u64,
    pub ask_price: u64,
    pub bid_size: u64,
    pub ask_size: u64,
    pub quote_sequence: u64,
    pub timestamp_nanos: u64,
}

impl MarketMaker {
    /// Generate two-sided quotes with inventory management
    #[inline(always)]
    pub fn generate_quotes(&self, symbol_id: u16, market_data: &TopOfBook) -> Option<QuoteUpdate> {
        let current_time = get_timestamp_nanos();
        let last_quote = self.last_quote_time.load(Ordering::Acquire);
        
        // Rate limiting: don't quote too frequently
        if current_time - last_quote < self.params.quote_refresh_nanos {
            return None;
        }
        
        // Check risk limits before generating quotes
        if !self.check_risk_limits(symbol_id) {
            return None;
        }
        
        let mid_price = (market_data.bid_price + market_data.ask_price) / 2;
        let current_position = self.positions[symbol_id as usize].load(Ordering::Acquire);
        
        // Calculate inventory-adjusted spread
        let base_spread = (mid_price * self.params.spread_bps as u64) / 10000;
        let inventory_skew = self.calculate_inventory_skew(current_position, symbol_id);
        
        // Adjust quotes based on inventory position
        let bid_adjustment = if current_position > 0 {
            // Long position: widen bid, tighten ask
            base_spread / 4 + inventory_skew
        } else {
            base_spread / 2
        };
        
        let ask_adjustment = if current_position < 0 {
            // Short position: tighten bid, widen ask  
            base_spread / 4 + inventory_skew
        } else {
            base_spread / 2
        };
        
        let bid_price = mid_price.saturating_sub(bid_adjustment);
        let ask_price = mid_price.saturating_add(ask_adjustment);
        
        // Size adjustment based on position
        let position_abs = current_position.abs() as u64;
        let remaining_capacity = self.params.max_inventory.saturating_sub(position_abs);
        
        let bid_size = if current_position < self.params.max_inventory as i64 {
            self.params.quote_size.min(remaining_capacity)
        } else {
            0 // Don't bid if at max long position
        };
        
        let ask_size = if current_position > -(self.params.max_inventory as i64) {
            self.params.quote_size.min(remaining_capacity)
        } else {
            0 // Don't offer if at max short position
        };
        
        // Update last quote time
        self.last_quote_time.store(current_time, Ordering::Release);
        
        Some(QuoteUpdate {
            symbol_id,
            bid_price,
            ask_price,
            bid_size,
            ask_size,
            quote_sequence: self.quote_sequence.fetch_add(1, Ordering::Relaxed),
            timestamp_nanos: current_time,
        })
    }
    
    /// Handle trade fill with position and PnL updates
    #[inline(always)]
    pub fn handle_fill(&self, symbol_id: u16, side: Side, price: u64, volume: u64) {
        let signed_volume = match side {
            Side::Buy => volume as i64,
            Side::Sell => -(volume as i64),
            _ => return,
        };
        
        // Update position atomically
        let old_position = self.positions[symbol_id as usize]
            .fetch_add(signed_volume, Ordering::AcqRel);
        let new_position = old_position + signed_volume;
        
        // Calculate realized PnL if position flipped or reduced
        if (old_position > 0 && new_position < old_position) ||
           (old_position < 0 && new_position > old_position) {
            // Position was reduced - calculate realized PnL
            let realized_volume = if old_position > 0 {
                volume.min(old_position as u64)
            } else {
                volume.min((-old_position) as u64)
            };
            
            // Simplified PnL calculation (would use FIFO/LIFO in production)
            let avg_cost = self.get_average_cost(symbol_id);
            let pnl_cents = ((price as i64 - avg_cost) * realized_volume as i64) / 100;
            
            self.realized_pnl_cents.fetch_add(
                if side == Side::Sell { pnl_cents } else { -pnl_cents },
                Ordering::Relaxed
            );
        }
        
        // Update unrealized PnL based on new position
        self.update_unrealized_pnl(symbol_id, new_position, price);
        
        // Increment fill counter
        self.fills_received.fetch_add(1, Ordering::Relaxed);
        
        // Log the fill for audit trail
        self.log_fill(symbol_id, side, price, volume, new_position);
    }
    
    /// Fast risk limit checking
    #[inline(always)]
    fn check_risk_limits(&self, symbol_id: u16) -> bool {
        let current_position = self.positions[symbol_id as usize].load(Ordering::Acquire);
        let unrealized_pnl = self.unrealized_pnl_cents.load(Ordering::Acquire);
        let realized_pnl = self.realized_pnl_cents.load(Ordering::Acquire);
        
        // Position limit check
        if current_position.abs() >= self.max_position_size as i64 {
            return false;
        }
        
        // Total PnL loss limit check
        if unrealized_pnl + realized_pnl < self.max_loss_cents {
            return false;
        }
        
        true
    }
    
    /// Calculate inventory skew adjustment
    #[inline(always)]
    fn calculate_inventory_skew(&self, position: i64, _symbol_id: u16) -> u64 {
        let position_ratio = position as f32 / self.params.max_inventory as f32;
        let skew_adjustment = position_ratio * self.params.skew_factor;
        
        // Convert back to price units (avoiding floating point in hot path)
        (skew_adjustment * 100.0) as u64
    }
    
    /// Get strategy performance metrics
    pub fn get_performance_stats(&self) -> StrategyStats {
        let orders_sent = self.orders_sent.load(Ordering::Acquire);
        let fills_received = self.fills_received.load(Ordering::Acquire);
        
        let fill_rate = if orders_sent > 0 {
            fills_received as f64 / orders_sent as f64
        } else {
            0.0
        };
        
        StrategyStats {
            realized_pnl_dollars: self.realized_pnl_cents.load(Ordering::Acquire) as f64 / 100.0,
            unrealized_pnl_dollars: self.unrealized_pnl_cents.load(Ordering::Acquire) as f64 / 100.0,
            fill_rate_percent: fill_rate * 100.0,
            orders_sent,
            fills_received,
            current_positions: self.get_all_positions(),
        }
    }
}

#[derive(Debug)]
pub struct StrategyStats {
    pub realized_pnl_dollars: f64,
    pub unrealized_pnl_dollars: f64,
    pub fill_rate_percent: f64,
    pub orders_sent: u64,
    pub fills_received: u64,
    pub current_positions: Vec<(u16, i64)>, // (symbol_id, position)
}

/// Ultra-low latency network interface using DPDK
pub struct DpdkNetworkInterface {
    /// Direct memory access to network buffers
    rx_ring: *mut dpdk_sys::rte_ring,
    tx_ring: *mut dpdk_sys::rte_ring,
    
    /// Pre-allocated packet buffers (huge pages)
    packet_pool: *mut dpdk_sys::rte_mempool,
    
    /// Network port configuration
    port_id: u16,
    queue_id: u16,
    
    /// Statistics
    packets_received: AtomicU64,
    packets_sent: AtomicU64,
    bytes_received: AtomicU64,
    bytes_sent: AtomicU64,
}

impl DpdkNetworkInterface {
    /// Initialize DPDK interface with optimal settings for HFT
    pub unsafe fn new(port_id: u16, core_id: u16) -> Result<Self, NetworkError> {
        // Initialize EAL (Environment Abstraction Layer)
        let args = vec![
            CString::new("hft_application").unwrap(),
            CString::new(format!("-c 0x{:x}", 1 << core_id)).unwrap(),
            CString::new("-n 4").unwrap(), // 4 memory channels
            CString::new("--huge-unlink").unwrap(),
            CString::new("--socket-mem=1024").unwrap(), // 1GB huge pages
        ];
        
        let mut argv: Vec<*mut c_char> = args.iter()
            .map(|arg| arg.as_ptr() as *mut c_char)
            .collect();
        
        let ret = dpdk_sys::rte_eal_init(argv.len() as c_int, argv.as_mut_ptr());
        if ret < 0 {
            return Err(NetworkError::EalInitFailed);
        }
        
        // Create packet buffer pool with optimal size
        let packet_pool = dpdk_sys::rte_pktmbuf_pool_create(
            b"mbuf_pool".as_ptr() as *const c_char,
            8192,  // Pool size
            256,   // Cache size  
            0,     // Private data size
            2048,  // Data room size
            dpdk_sys::rte_socket_id() as c_int,
        );
        
        if packet_pool.is_null() {
            return Err(NetworkError::PoolCreationFailed);
        }
        
        // Configure the port for minimal latency
        let mut port_conf: dpdk_sys::rte_eth_conf = std::mem::zeroed();
        port_conf.rxmode.mq_mode = dpdk_sys::rte_eth_rx_mq_mode::ETH_MQ_RX_RSS;
        port_conf.txmode.mq_mode = dpdk_sys::rte_eth_tx_mq_mode::ETH_MQ_TX_NONE;
        
        // Disable unnecessary features for maximum performance
        port_conf.rxmode.offloads = 0;
        port_conf.txmode.offloads = 0;
        
        let ret = dpdk_sys::rte_eth_dev_configure(port_id, 1, 1, &port_conf);
        if ret < 0 {
            return Err(NetworkError::PortConfigFailed);
        }
        
        // Setup RX queue with optimal parameters
        let ret = dpdk_sys::rte_eth_rx_queue_setup(
            port_id,
            0,    // Queue ID
            1024, // Ring size (power of 2)
            dpdk_sys::rte_socket_id(),
            ptr::null(), // Use default RX conf
            packet_pool,
        );
        
        if ret < 0 {
            return Err(NetworkError::RxQueueSetupFailed);
        }
        
        // Setup TX queue with optimal parameters
        let ret = dpdk_sys::rte_eth_tx_queue_setup(
            port_id,
            0,    // Queue ID  
            1024, // Ring size (power of 2)
            dpdk_sys::rte_socket_id(),
            ptr::null(), // Use default TX conf
        );
        
        if ret < 0 {
            return Err(NetworkError::TxQueueSetupFailed);
        }
        
        // Start the port
        let ret = dpdk_sys::rte_eth_dev_start(port_id);
        if ret < 0 {
            return Err(NetworkError::PortStartFailed);
        }
        
        Ok(Self {
            rx_ring: ptr::null_mut(), // Would be initialized in production
            tx_ring: ptr::null_mut(),
            packet_pool,
            port_id,
            queue_id: 0,
            packets_received: AtomicU64::new(0),
            packets_sent: AtomicU64::new(0),
            bytes_received: AtomicU64::new(0),
            bytes_sent: AtomicU64::new(0),
        })
    }
    
    /// Receive packets with zero-copy operations
    #[inline(always)]
    pub unsafe fn receive_burst(&self) -> &[*mut dpdk_sys::rte_mbuf] {
        const MAX_BURST_SIZE: usize = 32;
        static mut RX_BUFFER: [*mut dpdk_sys::rte_mbuf; MAX_BURST_SIZE] = 
            [ptr::null_mut(); MAX_BURST_SIZE];
        
        let nb_rx = dpdk_sys::rte_eth_rx_burst(
            self.port_id,
            self.queue_id,
            RX_BUFFER.as_mut_ptr(),
            MAX_BURST_SIZE as u16,
        );
        
        if nb_rx > 0 {
            self.packets_received.fetch_add(nb_rx as u64, Ordering::Relaxed);
            
            // Calculate total bytes received
            let mut total_bytes = 0u64;
            for i in 0..nb_rx as usize {
                let mbuf = RX_BUFFER[i];
                total_bytes += (*mbuf).data_len as u64;
            }
            self.bytes_received.fetch_add(total_bytes, Ordering::Relaxed);
        }
        
        &RX_BUFFER[..nb_rx as usize]
    }
    
    /// Send packets with minimal CPU overhead
    #[inline(always)]
    pub unsafe fn send_burst(&self, packets: &[*mut dpdk_sys::rte_mbuf]) -> u16 {
        let nb_tx = dpdk_sys::rte_eth_tx_burst(
            self.port_id,
            self.queue_id,
            packets.as_ptr() as *mut *mut dpdk_sys::rte_mbuf,
            packets.len() as u16,
        );
        
        if nb_tx > 0 {
            self.packets_sent.fetch_add(nb_tx as u64, Ordering::Relaxed);
            
            // Calculate total bytes sent
            let mut total_bytes = 0u64;
            for i in 0..nb_tx as usize {
                let mbuf = packets[i];
                total_bytes += (*mbuf).data_len as u64;
            }
            self.bytes_sent.fetch_add(total_bytes, Ordering::Relaxed);
        }
        
        nb_tx
    }
    
    /// Create outbound packet with zero allocations
    #[inline(always)]
    pub unsafe fn create_packet(&self, data: &[u8]) -> *mut dpdk_sys::rte_mbuf {
        let mbuf = dpdk_sys::rte_pktmbuf_alloc(self.packet_pool);
        if mbuf.is_null() {
            return ptr::null_mut();
        }
        
        // Get packet data pointer
        let packet_data = dpdk_sys::rte_pktmbuf_mtod(mbuf, *mut u8);
        
        // Copy data into packet buffer
        ptr::copy_nonoverlapping(data.as_ptr(), packet_data, data.len());
        
        // Set packet length
        (*mbuf).data_len = data.len() as u16;
        (*mbuf).pkt_len = data.len() as u32;
        
        mbuf
    }
    
    /// Get network interface statistics
    pub fn get_stats(&self) -> NetworkStats {
        NetworkStats {
            packets_received: self.packets_received.load(Ordering::Acquire),
            packets_sent: self.packets_sent.load(Ordering::Acquire),
            bytes_received: self.bytes_received.load(Ordering::Acquire),
            bytes_sent: self.bytes_sent.load(Ordering::Acquire),
            rx_rate_pps: self.calculate_rx_rate(),
            tx_rate_pps: self.calculate_tx_rate(),
        }
    }
}

#[derive(Debug)]
pub struct NetworkStats {
    pub packets_received: u64,
    pub packets_sent: u64,
    pub bytes_received: u64,
    pub bytes_sent: u64,
    pub rx_rate_pps: f64, // Packets per second
    pub tx_rate_pps: f64, // Packets per second
}

#[derive(Debug)]
pub enum NetworkError {
    EalInitFailed,
    PoolCreationFailed,
    PortConfigFailed,
    RxQueueSetupFailed,
    TxQueueSetupFailed,
    PortStartFailed,
}

/// High-performance monitoring system for HFT applications
pub struct HftMonitor {
    /// Metrics collection (lock-free)
    metrics: Arc<MetricsCollector>,
    
    /// Alert thresholds
    latency_threshold_nanos: u64,
    pnl_alert_threshold: i64,
    position_alert_threshold: u64,
    
    /// Alert channels
    alert_sender: crossbeam::channel::Sender<Alert>,
}

#[derive(Debug, Clone)]
pub struct TradingMetrics {
    pub timestamp_nanos: u64,
    pub symbol_id: u16,
    pub order_latency_nanos: u64,
    pub fill_latency_nanos: u64,
    pub current_position: i64,
    pub unrealized_pnl_cents: i64,
    pub orders_sent_per_second: f64,
    pub fills_per_second: f64,
    pub market_data_rate: f64,
}

impl HftMonitor {
    /// Record trading metrics with minimal overhead
    #[inline(always)]
    pub fn record_metrics(&self, metrics: TradingMetrics) {
        // Check for alert conditions
        if metrics.order_latency_nanos > self.latency_threshold_nanos {
            self.send_alert(Alert::HighLatency {
                symbol_id: metrics.symbol_id,
                latency_nanos: metrics.order_latency_nanos,
                timestamp: metrics.timestamp_nanos,
            });
        }
        
        if metrics.unrealized_pnl_cents < -self.pnl_alert_threshold {
            self.send_alert(Alert::LargeLoss {
                symbol_id: metrics.symbol_id,
                pnl_cents: metrics.unrealized_pnl_cents,
                timestamp: metrics.timestamp_nanos,
            });
        }
        
        if metrics.current_position.abs() as u64 > self.position_alert_threshold {
            self.send_alert(Alert::LargePosition {
                symbol_id: metrics.symbol_id,
                position: metrics.current_position,
                timestamp: metrics.timestamp_nanos,
            });
        }
        
        // Store metrics for analysis (non-blocking)
        self.metrics.record(metrics);
    }
    
    /// Generate real-time performance dashboard data
    pub fn get_dashboard_data(&self) -> DashboardData {
        let metrics = self.metrics.get_latest_window(Duration::from_secs(60));
        
        DashboardData {
            avg_order_latency_nanos: calculate_average_latency(&metrics),
            p99_order_latency_nanos: calculate_p99_latency(&metrics),
            total_pnl_dollars: calculate_total_pnl(&metrics),
            fill_rate_percent: calculate_fill_rate(&metrics),
            active_symbols: count_active_symbols(&metrics),
            system_health_score: calculate_health_score(&metrics),
            alerts_last_hour: self.get_recent_alerts(Duration::from_secs(3600)),
        }
    }
}

#[derive(Debug)]
pub enum Alert {
    HighLatency {
        symbol_id: u16,
        latency_nanos: u64,
        timestamp: u64,
    },
    LargeLoss {
        symbol_id: u16,
        pnl_cents: i64,
        timestamp: u64,
    },
    LargePosition {
        symbol_id: u16,
        position: i64,
        timestamp: u64,
    },
    SystemOverload {
        cpu_usage_percent: f32,
        memory_usage_bytes: u64,
        timestamp: u64,
    },
}

#[derive(Debug, Serialize)]
pub struct DashboardData {
    pub avg_order_latency_nanos: u64,
    pub p99_order_latency_nanos: u64,
    pub total_pnl_dollars: f64,
    pub fill_rate_percent: f64,
    pub active_symbols: u16,
    pub system_health_score: f32,
    pub alerts_last_hour: Vec<Alert>,
}