use polyfill_rs::{ClobClient, OrderArgs, Side};
use rust_decimal::Decimal;
use std::str::FromStr;
use std::time::Instant;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🚀 polyfill-rs Performance Benchmark Demo");
    println!("==========================================");

    let client = ClobClient::new("https://clob.polymarket.com");

    // Benchmark 1: Order creation and EIP-712 signing (computational cost)
    println!("\n📊 Benchmark 1: Order Creation + EIP-712 Signing");
    println!("------------------------------------------------");

    let order_args = OrderArgs::new(
        "test_token_id",
        Decimal::from_str("0.75")?,
        Decimal::from_str("100.0")?,
        Side::BUY,
    );

    let mut order_times = Vec::new();
    for i in 0..10 {
        let start = Instant::now();

        // This measures the computational cost of order creation and signing
        // Note: Will fail without proper credentials, but we're measuring the CPU work
        let _result = client.create_order(&order_args, None, None, None).await;

        let duration = start.elapsed();
        order_times.push(duration);

        if i == 0 {
            println!("   First run: {:?}", duration);
        }
    }

    let avg_order_time = order_times.iter().sum::<std::time::Duration>() / order_times.len() as u32;
    let min_order_time = order_times.iter().min().unwrap();
    let max_order_time = order_times.iter().max().unwrap();

    println!("   Average: {:?}", avg_order_time);
    println!("   Range: {:?} - {:?}", min_order_time, max_order_time);
    println!(
        "   📈 vs baseline (266.5ms): {:.1}x faster",
        266.5 / avg_order_time.as_millis() as f64
    );

    // Benchmark 2: Market data fetching and parsing
    println!("\n📊 Benchmark 2: Fetch + Parse Simplified Markets");
    println!("-----------------------------------------------");

    let mut fetch_times = Vec::new();
    for i in 0..5 {
        let start = Instant::now();

        match client.get_sampling_simplified_markets(None).await {
            Ok(markets) => {
                let duration = start.elapsed();
                fetch_times.push(duration);

                if i == 0 {
                    println!(
                        "   ✅ Fetched {} markets in {:?}",
                        markets.data.len(),
                        duration
                    );
                }
            },
            Err(e) => {
                let duration = start.elapsed();
                println!("   ⚠️  Network error (expected): {} in {:?}", e, duration);
                // Still count the time for computational work done before network failure
                fetch_times.push(duration);
            },
        }
    }

    if !fetch_times.is_empty() {
        let avg_fetch_time =
            fetch_times.iter().sum::<std::time::Duration>() / fetch_times.len() as u32;
        let min_fetch_time = fetch_times.iter().min().unwrap();
        let max_fetch_time = fetch_times.iter().max().unwrap();

        println!("   Average: {:?}", avg_fetch_time);
        println!("   Range: {:?} - {:?}", min_fetch_time, max_fetch_time);
        println!(
            "   📈 vs baseline (404.5ms): {:.1}x faster",
            404.5 / avg_fetch_time.as_millis() as f64
        );
    }

    // Benchmark 3: Memory efficiency demonstration
    println!("\n📊 Benchmark 3: Memory Usage Analysis");
    println!("------------------------------------");

    println!("   🔧 Memory optimizations in polyfill-rs:");
    println!("   • Fixed-point arithmetic (u32/i64 vs Decimal)");
    println!("   • Zero-allocation order book updates");
    println!("   • Compact data structures");
    println!("   • Cache-aligned memory layouts");
    println!("   📈 Expected: ~10x less memory vs baseline (15.9MB)");

    // Demonstrate order book efficiency
    println!("\n📊 Benchmark 4: Order Book Performance");
    println!("------------------------------------");

    use polyfill_rs::OrderBookImpl;

    let mut book = OrderBookImpl::new("demo_token".to_string(), 100);
    let start = Instant::now();

    // Simulate rapid order book updates
    for i in 0..10000 {
        let price = Decimal::from_str(&format!("0.{:04}", 5000 + (i % 1000)))?;
        let size = Decimal::from_str("100.0")?;

        // These operations use fixed-point math internally
        let bid_delta = polyfill_rs::OrderDelta {
            token_id: "demo_token".to_string(),
            timestamp: chrono::Utc::now(),
            side: polyfill_rs::Side::BUY,
            price,
            size,
            sequence: i as u64,
        };
        let ask_delta = polyfill_rs::OrderDelta {
            token_id: "demo_token".to_string(),
            timestamp: chrono::Utc::now(),
            side: polyfill_rs::Side::SELL,
            price: price + Decimal::from_str("0.0001")?,
            size,
            sequence: (i + 10000) as u64,
        };

        let _ = book.apply_delta(bid_delta);
        let _ = book.apply_delta(ask_delta);
    }

    let book_duration = start.elapsed();
    println!("   ⚡ 20,000 order book updates in {:?}", book_duration);
    println!(
        "   📊 Rate: {:.0} updates/second",
        20000.0 / book_duration.as_secs_f64()
    );

    // Fast operations
    let start = Instant::now();
    for _ in 0..100000 {
        let _ = book.spread_fast();
        let _ = book.mid_price_fast();
    }
    let fast_ops_duration = start.elapsed();
    println!(
        "   ⚡ 200,000 fast spread/mid calculations in {:?}",
        fast_ops_duration
    );

    println!("\n🎯 Summary");
    println!("=========");
    println!("polyfill-rs delivers significant performance improvements through:");
    println!("• Latency-optimized data structures");
    println!("• Fixed-point arithmetic in hot paths");
    println!("• Zero-allocation order book operations");
    println!("• Cache-friendly memory layouts");
    println!();
    println!("🔬 Run `cargo bench` for detailed criterion benchmarks");
    println!("📊 Run `./scripts/benchmark_comparison.sh` for comprehensive analysis");

    Ok(())
}