foxhunt/adaptive-strategy/src/models/batch_tlob_processor.rs

//! High-performance batch processing for TLOB order book snapshots
//! Target: Process 32 order books in <40μs total

use std::sync::Arc;
use std::time::Instant;

use anyhow::Result;
// STUB: ML dependency moved to service
// use ml::tlob::{TLOBTransformer, TLOBFeatures, FeatureVector};
use super::tlob_model::FeatureVector;
pub type TLOBTransformer = u32;
pub type TLOBFeatures = Vec<f64>;
use tracing::{debug, instrument, warn};

/// Batch processor for multiple order book snapshots
pub struct BatchTLOBProcessor {
    transformer: Arc<TLOBTransformer>,
    batch_size: usize,
    // Pre-allocated buffers for zero-allocation processing
    input_buffer: Vec<TLOBFeatures>,
    output_buffer: Vec<FeatureVector>,
    total_processed: u64,
    total_batch_time_ns: u64,
}

impl BatchTLOBProcessor {
    /// Create new batch processor
    pub fn new(transformer: Arc<TLOBTransformer>, batch_size: usize) -> Self {
        let effective_batch_size = batch_size.min(32); // HFT constraint
        
        Self {
            transformer,
            batch_size: effective_batch_size,
            input_buffer: Vec::with_capacity(effective_batch_size),
            output_buffer: Vec::with_capacity(effective_batch_size),
            total_processed: 0,
            total_batch_time_ns: 0,
        }
    }

    /// Process multiple order book snapshots in batch
    /// Target: <40μs for 32 order books
    #[instrument(skip(self, order_books))]
    pub fn process_batch(&mut self, order_books: &[TLOBFeatures]) -> Result<Vec<FeatureVector>> {
        let start = Instant::now();
        
        // Clear and prepare buffers (reuse allocations)
        self.input_buffer.clear();
        self.output_buffer.clear();
        
        let mut results = Vec::with_capacity(order_books.len());
        
        // Process in chunks of batch_size
        for chunk in order_books.chunks(self.batch_size) {
            // Fill input buffer
            self.input_buffer.extend_from_slice(chunk);
            
            // Process batch - this is the critical performance path
            for ob in &self.input_buffer {
                match self.transformer.predict(ob) {
                    Ok(prediction) => {
                        self.output_buffer.push(prediction);
                    }
                    Err(e) => {
                        warn!("Batch prediction failed for order book: {}", e);
                        // Continue processing other order books
                        continue;
                    }
                }
            }
            
            // Move results to output
            results.extend(self.output_buffer.drain(..));
            self.input_buffer.clear();
        }
        
        let elapsed = start.elapsed().as_nanos() as u64;
        
        // Update performance metrics
        self.total_processed += order_books.len() as u64;
        self.total_batch_time_ns += elapsed;
        
        // Performance validation
        let target_ns = 40_000; // 40μs target
        if elapsed > target_ns {
            warn!(
                "Batch processing exceeded target: {}ns > {}ns for {} order books",
                elapsed, target_ns, order_books.len()
            );
        } else {
            debug!(
                "Batch processed {} order books in {}ns ({}ns per book)",
                order_books.len(),
                elapsed,
                elapsed / order_books.len() as u64
            );
        }
        
        Ok(results)
    }

    /// Process single order book with batch infrastructure
    pub fn process_single(&mut self, order_book: &TLOBFeatures) -> Result<FeatureVector> {
        let start = Instant::now();
        
        let prediction = self.transformer.predict(order_book)?;
        
        let elapsed = start.elapsed().as_nanos() as u64;
        self.total_processed += 1;
        self.total_batch_time_ns += elapsed;
        
        Ok(prediction)
    }

    /// Get average processing time per order book in nanoseconds
    pub fn avg_processing_time_ns(&self) -> u64 {
        if self.total_processed > 0 {
            self.total_batch_time_ns / self.total_processed
        } else {
            0
        }
    }

    /// Get total number of order books processed
    pub fn total_processed(&self) -> u64 {
        self.total_processed
    }

    /// Get configured batch size
    pub fn batch_size(&self) -> usize {
        self.batch_size
    }

    /// Reset performance metrics
    pub fn reset_metrics(&mut self) {
        self.total_processed = 0;
        self.total_batch_time_ns = 0;
    }

    /// Check if batch processor is optimally configured
    pub fn is_optimal_config(&self) -> bool {
        // Optimal configuration checks:
        // 1. Batch size should be power of 2 for cache efficiency
        // 2. Should not exceed 32 for HFT constraints
        // 3. Should be at least 4 for vectorization benefits
        
        let is_power_of_2 = self.batch_size > 0 && (self.batch_size & (self.batch_size - 1)) == 0;
        let is_reasonable_size = self.batch_size >= 4 && self.batch_size <= 32;
        
        is_power_of_2 && is_reasonable_size
    }

    /// Get memory usage estimate in bytes
    pub fn memory_usage(&self) -> usize {
        let base_size = std::mem::size_of::<Self>();
        let input_buffer_size = self.input_buffer.capacity() * std::mem::size_of::<TLOBFeatures>();
        let output_buffer_size = self.output_buffer.capacity() * std::mem::size_of::<FeatureVector>();
        
        base_size + input_buffer_size + output_buffer_size
    }
}

/// Batch processing configuration for optimal performance
#[derive(Debug, Clone)]
pub struct BatchProcessingConfig {
    pub batch_size: usize,
    pub max_latency_ns: u64,
    pub enable_parallel_processing: bool,
    pub memory_limit_bytes: usize,
}

impl Default for BatchProcessingConfig {
    fn default() -> Self {
        Self {
            batch_size: 16, // Optimal for most HFT scenarios
            max_latency_ns: 40_000, // 40μs target
            enable_parallel_processing: true,
            memory_limit_bytes: 1024 * 1024, // 1MB limit
        }
    }
}

impl BatchProcessingConfig {
    /// Create configuration optimized for ultra-low latency
    pub fn ultra_low_latency() -> Self {
        Self {
            batch_size: 8, // Smaller batch for lower latency
            max_latency_ns: 20_000, // 20μs target
            enable_parallel_processing: true,
            memory_limit_bytes: 512 * 1024, // 512KB limit
        }
    }

    /// Create configuration optimized for high throughput
    pub fn high_throughput() -> Self {
        Self {
            batch_size: 32, // Maximum batch size
            max_latency_ns: 60_000, // 60μs target (more relaxed)
            enable_parallel_processing: true,
            memory_limit_bytes: 2 * 1024 * 1024, // 2MB limit
        }
    }

    /// Validate configuration for HFT constraints
    pub fn validate(&self) -> Result<()> {
        if self.batch_size == 0 {
            anyhow::bail!("Batch size must be greater than 0");
        }
        
        if self.batch_size > 32 {
            anyhow::bail!("Batch size cannot exceed 32 for HFT performance");
        }
        
        if self.max_latency_ns < 10_000 {
            anyhow::bail!("Maximum latency cannot be less than 10μs");
        }
        
        if self.memory_limit_bytes < 128 * 1024 {
            anyhow::bail!("Memory limit too restrictive (minimum 128KB)");
        }
        
        Ok(())
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    // STUB: use ml::tlob::TLOBConfig;
    pub type TLOBConfig = u32;

    fn create_test_transformer() -> Arc<TLOBTransformer> {
        let config = TLOBConfig::default();
        Arc::new(TLOBTransformer::new(config).unwrap())
    }

    fn create_test_order_book(base_price: f64) -> TLOBFeatures {
        // STUB: ml::tlob::TLOBFeatures::new(
        vec![
            chrono::Utc::now().timestamp_micros() as u64,
            "TEST".to_string(),
            vec![(base_price * 10000.0) as i64; 5], // Bid prices
            vec![((base_price + 0.01) * 10000.0) as i64; 5], // Ask prices
            vec![1000; 5], // Bid volumes
            vec![1100; 5], // Ask volumes
            (base_price * 10000.0) as i64, // Last price
            5000, // Volume
            0.02, // Volatility
            0.001, // Momentum
            vec![0.1; 10], // Microstructure features
        ).unwrap()
    }

    #[test]
    fn test_batch_processor_creation() {
        let transformer = create_test_transformer();
        let processor = BatchTLOBProcessor::new(transformer, 16);
        
        assert_eq!(processor.batch_size(), 16);
        assert_eq!(processor.total_processed(), 0);
        assert!(processor.is_optimal_config());
    }

    #[test]
    fn test_single_order_book_processing() {
        let transformer = create_test_transformer();
        let mut processor = BatchTLOBProcessor::new(transformer, 8);
        
        let order_book = create_test_order_book(100.0);
        let result = processor.process_single(&order_book);
        
        assert!(result.is_ok());
        assert_eq!(processor.total_processed(), 1);
        assert!(processor.avg_processing_time_ns() > 0);
    }

    #[test]
    fn test_batch_processing() {
        let transformer = create_test_transformer();
        let mut processor = BatchTLOBProcessor::new(transformer, 4);
        
        // Create multiple order books
        let order_books: Vec<_> = (0..8)
            .map(|i| create_test_order_book(100.0 + i as f64))
            .collect();
        
        let results = processor.process_batch(&order_books);
        
        assert!(results.is_ok());
        let predictions = results.unwrap();
        assert_eq!(predictions.len(), 8);
        assert_eq!(processor.total_processed(), 8);
    }

    #[test]
    fn test_batch_size_constraints() {
        let transformer = create_test_transformer();
        
        // Test maximum batch size constraint
        let processor = BatchTLOBProcessor::new(transformer.clone(), 64);
        assert_eq!(processor.batch_size(), 32); // Should be clamped to 32
        
        // Test reasonable batch size
        let processor = BatchTLOBProcessor::new(transformer, 16);
        assert_eq!(processor.batch_size(), 16);
    }

    #[test]
    fn test_performance_metrics() {
        let transformer = create_test_transformer();
        let mut processor = BatchTLOBProcessor::new(transformer, 8);
        
        let order_book = create_test_order_book(100.0);
        
        // Process several order books
        for _ in 0..5 {
            let _ = processor.process_single(&order_book);
        }
        
        assert_eq!(processor.total_processed(), 5);
        assert!(processor.avg_processing_time_ns() > 0);
        
        // Test metrics reset
        processor.reset_metrics();
        assert_eq!(processor.total_processed(), 0);
    }

    #[test]
    fn test_batch_processing_config() {
        let config = BatchProcessingConfig::default();
        assert!(config.validate().is_ok());
        
        let ultra_low = BatchProcessingConfig::ultra_low_latency();
        assert!(ultra_low.validate().is_ok());
        assert_eq!(ultra_low.batch_size, 8);
        assert_eq!(ultra_low.max_latency_ns, 20_000);
        
        let high_throughput = BatchProcessingConfig::high_throughput();
        assert!(high_throughput.validate().is_ok());
        assert_eq!(high_throughput.batch_size, 32);
        assert_eq!(high_throughput.max_latency_ns, 60_000);
    }

    #[test]
    fn test_config_validation() {
        let mut config = BatchProcessingConfig::default();
        
        // Test invalid batch size
        config.batch_size = 0;
        assert!(config.validate().is_err());
        
        config.batch_size = 64; // Too large
        assert!(config.validate().is_err());
        
        // Test invalid latency
        config.batch_size = 16;
        config.max_latency_ns = 5_000; // Too strict
        assert!(config.validate().is_err());
        
        // Test invalid memory limit
        config.max_latency_ns = 40_000;
        config.memory_limit_bytes = 1024; // Too small
        assert!(config.validate().is_err());
    }

    #[test]
    fn test_optimal_configuration_check() {
        let transformer = create_test_transformer();
        
        // Test optimal configurations (powers of 2)
        for &size in &[4, 8, 16, 32] {
            let processor = BatchTLOBProcessor::new(transformer.clone(), size);
            assert!(processor.is_optimal_config(), "Batch size {} should be optimal", size);
        }
        
        // Test non-optimal configurations
        for &size in &[3, 5, 6, 7, 9, 10] {
            let processor = BatchTLOBProcessor::new(transformer.clone(), size);
            assert!(!processor.is_optimal_config(), "Batch size {} should not be optimal", size);
        }
    }

    #[test]
    fn test_memory_usage_estimation() {
        let transformer = create_test_transformer();
        let processor = BatchTLOBProcessor::new(transformer, 16);
        
        let memory_usage = processor.memory_usage();
        assert!(memory_usage > 0);
        
        // Memory usage should scale with batch size
        let large_processor = BatchTLOBProcessor::new(create_test_transformer(), 32);
        assert!(large_processor.memory_usage() > memory_usage);
    }
}