foxhunt/trading_engine/examples/event_processing_demo.rs

//! High-Performance Event Processing Demo
//!
//! This example demonstrates the event processing pipeline with:
//! - Sub-microsecond event capture
//! - Batched PostgreSQL persistence
//! - Real-time monitoring and metrics
//! - Error recovery and guaranteed delivery

use anyhow::Result;
use rust_decimal_macros::dec;
use std::time::Duration;
use tokio::time::sleep;

use trading_engine::events::{
    EventLevel, EventMetadata, EventProcessor, EventProcessorConfig, TradingEvent,
};
use trading_engine::prelude::{AlertSeverity, RiskAlertType, SystemEventType};
use trading_engine::timing::HardwareTimestamp;

#[tokio::main]
async fn main() -> Result<()> {
    // Initialize tracing
    tracing_subscriber::fmt::init();
    println!("📝 Logging initialized");

    println!("🚀 Starting High-Performance Event Processing Demo");

    // Configure event processor for demo
    let config = EventProcessorConfig {
        // Use a test database or in-memory database for demo
        database_url: std::env::var("DATABASE_URL").unwrap_or_else(|_| {
            "postgresql://foxhunt:foxhunt@localhost/trading_events_demo".to_string()
        }),
        buffer_count: 4,
        buffer_size: 1024,
        batch_size: 100,
        batch_timeout_ms: 50,
        writer_threads: 2,
        max_db_connections: 10,
        db_timeout_seconds: 10,
        enable_compression: true,
        max_memory_usage: 50 * 1024 * 1024, // 50MB for demo
        enable_monitoring: true,
        max_retry_attempts: 3,
        retry_delay_ms: 100,
    };

    // Initialize event processor
    println!("📊 Initializing event processor...");
    let processor = match EventProcessor::new(config).await {
        Ok(p) => p,
        Err(e) => {
            eprintln!("❌ Failed to initialize event processor: {}", e);
            eprintln!("💡 Make sure PostgreSQL is running and accessible");
            eprintln!("💡 Create database: CREATE DATABASE trading_events_demo;");
            return Err(e);
        }
    };

    println!("✅ Event processor initialized successfully");

    // Demo 1: High-frequency order events
    println!("\n📈 Demo 1: High-frequency order events");
    demo_order_events(&processor).await?;

    // Demo 2: Risk monitoring events
    println!("\n⚠️  Demo 2: Risk monitoring events");
    demo_risk_events(&processor).await?;

    // Demo 3: System events
    println!("\n🔧 Demo 3: System events");
    demo_system_events(&processor).await?;

    // Demo 4: Performance stress test
    println!("\n⚡ Demo 4: Performance stress test");
    demo_performance_test(&processor).await?;

    // Demo 5: Monitoring and metrics
    println!("\n📊 Demo 5: Monitoring and metrics");
    demo_monitoring(&processor).await?;

    // Graceful shutdown
    println!("\n🛑 Shutting down event processor...");
    processor.shutdown().await?;
    println!("✅ Event processor shutdown complete");

    Ok(())
}

/// Demonstrate high-frequency order processing events
async fn demo_order_events(processor: &EventProcessor) -> Result<()> {
    let symbols = ["EURUSD", "GBPUSD", "USDJPY", "AUDUSD"];
    let mut order_counter = 1;

    println!("   Capturing 100 order events...");

    for i in 0..100 {
        let symbol = symbols[i % symbols.len()];
        let order_id = format!("ORD-{:06}", order_counter);
        order_counter += 1;

        // Create order submission event
        let event = TradingEvent::OrderSubmitted {
            order_id: order_id.clone(),
            symbol: symbol.to_string(),
            quantity: dec!(100000) + Decimal::from(i * 1000),
            price: dec!(1.0850) + Decimal::from(i) / dec!(10000),
            timestamp: HardwareTimestamp::now(),
            sequence_number: None, // Will be set by processor
            metadata: Some(serde_json::json!({
                "strategy": "mean_reversion",
                "session": "london",
                "demo_source": "order_events"
            })),
        };

        // Capture event (sub-microsecond performance)
        match processor.capture_event(event).await {
            Ok(sequence) => {
                if i % 20 == 0 {
                    println!(
                        "   📝 Order {} captured (seq: {})",
                        order_id,
                        sequence.number()
                    );
                }
            }
            Err(e) => {
                eprintln!("   ❌ Failed to capture order {}: {}", order_id, e);
            }
        }

        // Small delay to prevent overwhelming the system in demo
        if i % 10 == 0 {
            sleep(Duration::from_millis(1)).await;
        }
    }

    println!("   ✅ Order events captured successfully");
    Ok(())
}

/// Demonstrate risk monitoring events
async fn demo_risk_events(processor: &EventProcessor) -> Result<()> {
    println!("   Generating risk alerts...");

    let risk_scenarios = [
        (
            RiskAlertType::PositionSizeLimit,
            AlertSeverity::High,
            "Position size exceeded 80% of limit for EURUSD",
        ),
        (
            RiskAlertType::DailyLossLimit,
            AlertSeverity::Critical,
            "Daily loss approaching 90% of limit",
        ),
        (
            RiskAlertType::VolatilitySpike,
            AlertSeverity::Medium,
            "Volatility spike detected in GBPUSD",
        ),
        (
            RiskAlertType::LiquidityConstraint,
            AlertSeverity::Low,
            "Low liquidity detected in overnight session",
        ),
    ];

    for (alert_type, severity, message) in risk_scenarios {
        let event = TradingEvent::RiskAlert {
            alert_type,
            symbol: Some("EURUSD".to_string()),
            message: message.to_string(),
            severity,
            timestamp: HardwareTimestamp::now(),
            sequence_number: None,
            metadata: Some(serde_json::json!({
                "risk_engine": "var_calculator",
                "threshold_breached": true,
                "demo_source": "risk_events"
            })),
        };

        match processor.capture_event(event).await {
            Ok(sequence) => {
                println!(
                    "   🚨 Risk alert captured: {} (seq: {})",
                    message,
                    sequence.number()
                );
            }
            Err(e) => {
                eprintln!("   ❌ Failed to capture risk alert: {}", e);
            }
        }

        sleep(Duration::from_millis(100)).await;
    }

    println!("   ✅ Risk events captured successfully");
    Ok(())
}

/// Demonstrate system events
async fn demo_system_events(processor: &EventProcessor) -> Result<()> {
    println!("   Generating system events...");

    let system_scenarios = [
        (
            SystemEventType::ServiceConnected,
            EventLevel::Info,
            "Market data feed connected",
        ),
        (
            SystemEventType::ConfigurationChange,
            EventLevel::Warning,
            "Risk limits updated",
        ),
        (
            SystemEventType::PerformanceDegradation,
            EventLevel::Error,
            "Latency spike detected",
        ),
        (
            SystemEventType::Custom("maintenance".to_string()),
            EventLevel::Info,
            "Scheduled maintenance window started",
        ),
    ];

    for (event_type, level, message) in system_scenarios {
        let event = TradingEvent::SystemEvent {
            event_type,
            message: message.to_string(),
            level,
            timestamp: HardwareTimestamp::now(),
            sequence_number: None,
            metadata: Some(serde_json::json!({
                "service": "trading_engine",
                "version": "1.0.0",
                "demo_source": "system_events"
            })),
        };

        match processor.capture_event(event).await {
            Ok(sequence) => {
                println!(
                    "   🔧 System event captured: {} (seq: {})",
                    message,
                    sequence.number()
                );
            }
            Err(e) => {
                eprintln!("   ❌ Failed to capture system event: {}", e);
            }
        }

        sleep(Duration::from_millis(50)).await;
    }

    println!("   ✅ System events captured successfully");
    Ok(())
}

/// Demonstrate high-performance stress test
async fn demo_performance_test(processor: &EventProcessor) -> Result<()> {
    println!("   Running performance stress test (1000 events)...");

    let start_time = std::time::Instant::now();
    let mut successful_captures = 0;
    let mut failed_captures = 0;

    // Capture 1000 events as fast as possible
    for i in 0..1000 {
        let event = TradingEvent::OrderExecuted {
            trade_id: format!("TRADE-{:06}", i),
            symbol: "EURUSD".to_string(),
            quantity: dec!(50000),
            price: dec!(1.0851) + Decimal::from(i % 100) / dec!(100000),
            timestamp: HardwareTimestamp::now(),
            sequence_number: None,
            metadata: Some(serde_json::json!({
                "execution_venue": "prime_broker",
                "demo_source": "performance_test"
            })),
        };

        match processor.capture_event(event).await {
            Ok(_) => successful_captures += 1,
            Err(_) => failed_captures += 1,
        }
    }

    let elapsed = start_time.elapsed();
    let events_per_second = successful_captures as f64 / elapsed.as_secs_f64();
    let avg_latency_us = elapsed.as_micros() / successful_captures as u128;

    println!("   📊 Performance Results:");
    println!("      ⚡ Events/second: {:.0}", events_per_second);
    println!("      🕐 Avg latency: {} μs", avg_latency_us);
    println!("      ✅ Successful: {}", successful_captures);
    println!("      ❌ Failed: {}", failed_captures);

    Ok(())
}

/// Demonstrate monitoring and metrics
async fn demo_monitoring(processor: &EventProcessor) -> Result<()> {
    println!("   Collecting metrics and health status...");

    // Get current metrics
    let metrics = processor.get_metrics();
    println!("   📊 Current Metrics:");
    println!("      📈 Events captured: {}", metrics.events_captured);
    println!("      📉 Events dropped: {}", metrics.events_dropped);
    println!("      💾 Events written: {}", metrics.events_written);
    println!("      ⚡ Events/sec: {}", metrics.events_per_second);
    println!(
        "      🕐 Avg capture latency: {} ns",
        metrics.avg_capture_latency_ns
    );
    println!(
        "      💽 Avg write latency: {:.2} ms",
        metrics.avg_write_latency_ms
    );

    // Get health status
    let health = processor.get_health().await;
    println!("   🏥 Health Status: {:?}", health);

    // Get buffer statistics
    let buffer_stats = processor.get_buffer_stats().await;
    println!("   🔧 Buffer Statistics:");
    for stats in buffer_stats {
        println!(
            "      Buffer {}: {:.1}% utilization, {} pushes, {} pops",
            stats.buffer_id,
            stats.current_utilization * 100.0,
            stats.push_success_count,
            stats.pop_success_count
        );
    }

    Ok(())
}