foxhunt/tests/load_tests/src/lib.rs

//! Common utilities for load testing Trading Service
//!
//! Shared infrastructure for metrics, client connections, and order generation.

use std::sync::atomic::{AtomicU64, Ordering};
use std::time::Duration;
use tonic::transport::Channel;

// gRPC generated code
pub mod trading {
    tonic::include_proto!("trading");
}

pub use trading::trading_service_client::TradingServiceClient;
pub use trading::{OrderSide, OrderType, SubmitOrderRequest};

/// Performance metrics aggregator
#[derive(Debug)]
pub struct PerformanceMetrics {
    pub latencies_ns: Vec<u64>,
    pub successful_orders: AtomicU64,
    pub failed_orders: AtomicU64,
    pub total_orders: AtomicU64,
    pub test_duration: Duration,
}

impl PerformanceMetrics {
    pub fn new() -> Self {
        Self {
            latencies_ns: Vec::new(),
            successful_orders: AtomicU64::new(0),
            failed_orders: AtomicU64::new(0),
            total_orders: AtomicU64::new(0),
            test_duration: Duration::ZERO,
        }
    }

    pub fn record_success(&self, _latency_ns: u64) {
        self.successful_orders.fetch_add(1, Ordering::Relaxed);
        self.total_orders.fetch_add(1, Ordering::Relaxed);
    }

    pub fn record_failure(&self) {
        self.failed_orders.fetch_add(1, Ordering::Relaxed);
        self.total_orders.fetch_add(1, Ordering::Relaxed);
    }

    pub fn calculate_percentiles(mut latencies: Vec<u64>) -> (u64, u64, u64, u64, u64) {
        if latencies.is_empty() {
            return (0, 0, 0, 0, 0);
        }

        latencies.sort_unstable();
        let len = latencies.len();

        let min = latencies[0];
        let p50 = latencies[len / 2];
        let p95 = latencies[(len as f64 * 0.95) as usize];
        let p99 = latencies[(len as f64 * 0.99) as usize];
        let max = latencies[len - 1];

        (min, p50, p95, p99, max)
    }

    pub fn print_summary(&self, latencies: &[u64]) {
        let successful = self.successful_orders.load(Ordering::Relaxed);
        let failed = self.failed_orders.load(Ordering::Relaxed);
        let total = self.total_orders.load(Ordering::Relaxed);

        let success_rate = if total > 0 {
            (successful as f64 / total as f64) * 100.0
        } else {
            0.0
        };

        let throughput = if self.test_duration.as_secs_f64() > 0.0 {
            successful as f64 / self.test_duration.as_secs_f64()
        } else {
            0.0
        };

        let (min, p50, p95, p99, max) = Self::calculate_percentiles(latencies.to_vec());

        println!("\n╔═══════════════════════════════════════════════════════════╗");
        println!("║           TRADING SERVICE LOAD TEST RESULTS               ║");
        println!("╠═══════════════════════════════════════════════════════════╣");
        println!(
            "║ Test Duration:       {:.2}s",
            self.test_duration.as_secs_f64()
        );
        println!("║ Total Orders:        {}", total);
        println!(
            "║ Successful Orders:   {} ({:.2}%)",
            successful, success_rate
        );
        println!("║ Failed Orders:       {}", failed);
        println!("║ Throughput:          {:.0} orders/sec", throughput);
        println!("╠═══════════════════════════════════════════════════════════╣");
        println!("║                    LATENCY METRICS                        ║");
        println!("╠═══════════════════════════════════════════════════════════╣");
        println!(
            "║ Min Latency:         {:.2}ms ({:.2}μs)",
            min as f64 / 1_000_000.0,
            min as f64 / 1_000.0
        );
        println!(
            "║ P50 Latency:         {:.2}ms ({:.2}μs)",
            p50 as f64 / 1_000_000.0,
            p50 as f64 / 1_000.0
        );
        println!(
            "║ P95 Latency:         {:.2}ms ({:.2}μs)",
            p95 as f64 / 1_000_000.0,
            p95 as f64 / 1_000.0
        );
        println!(
            "║ P99 Latency:         {:.2}ms ({:.2}μs)",
            p99 as f64 / 1_000_000.0,
            p99 as f64 / 1_000.0
        );
        println!(
            "║ Max Latency:         {:.2}ms ({:.2}μs)",
            max as f64 / 1_000_000.0,
            max as f64 / 1_000.0
        );
        println!("╚═══════════════════════════════════════════════════════════╝");

        // Performance assessment
        println!("\n📊 PERFORMANCE ASSESSMENT:");

        if throughput >= 10_000.0 {
            println!(
                "✅ Throughput target ACHIEVED: {:.0} orders/sec (target: 10K orders/sec)",
                throughput
            );
        } else {
            println!(
                "⚠️  Throughput BELOW target: {:.0} orders/sec (target: 10K orders/sec)",
                throughput
            );
        }

        if p99 < 100_000_000 {
            // 100ms in nanoseconds
            println!(
                "✅ P99 latency GOOD: {:.2}ms (< 100ms)",
                p99 as f64 / 1_000_000.0
            );
        } else {
            println!(
                "⚠️  P99 latency HIGH: {:.2}ms (> 100ms)",
                p99 as f64 / 1_000_000.0
            );
        }

        if success_rate >= 99.0 {
            println!("✅ Success rate EXCELLENT: {:.2}%", success_rate);
        } else if success_rate >= 95.0 {
            println!("⚠️  Success rate ACCEPTABLE: {:.2}%", success_rate);
        } else {
            println!("❌ Success rate POOR: {:.2}%", success_rate);
        }
    }
}

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

/// Create a test order request
pub fn create_order_request(index: u64) -> SubmitOrderRequest {
    let symbols = ["BTC/USD", "ETH/USD", "SOL/USD", "AVAX/USD", "MATIC/USD"];
    let symbol = symbols[(index % symbols.len() as u64) as usize].to_string();

    SubmitOrderRequest {
        symbol,
        side: if index % 2 == 0 {
            OrderSide::Buy.into()
        } else {
            OrderSide::Sell.into()
        },
        order_type: OrderType::Limit.into(),
        quantity: 1.0 + (index % 10) as f64 * 0.1,
        price: Some(50000.0 + (index % 1000) as f64),
        stop_price: None,
        account_id: format!("test_account_{}", index % 10),
        metadata: std::collections::HashMap::new(),
    }
}

/// Connect to Trading Service
pub async fn connect_trading_service(
) -> Result<TradingServiceClient<Channel>, Box<dyn std::error::Error>> {
    let endpoint = "http://localhost:50052";
    println!("🔌 Connecting to Trading Service at {}", endpoint);

    let channel = Channel::from_static("http://localhost:50052")
        .connect_timeout(Duration::from_secs(10))
        .timeout(Duration::from_secs(30))
        .connect()
        .await?;

    let client = TradingServiceClient::new(channel);
    println!("✅ Connected successfully");

    Ok(client)
}