//! Rate Limiter Usage Examples
//!
//! Demonstrates how to use the RateLimiter in different scenarios

use anyhow::Result;
use uuid::Uuid;
use api_gateway::routing::RateLimiter;

// Note: This is a pseudo-code example showing integration patterns
// The actual types would come from the api_gateway crate

/// Example 1: Basic rate limit check in authentication flow
async fn example_auth_flow(
    rate_limiter: &RateLimiter,
    user_id: &Uuid,
    endpoint: &str,
) -> Result<()> {
    // Check rate limit before processing request
    let allowed = rate_limiter
        .check_limit(user_id, endpoint)
        .await?;

    if !allowed {
        return Err(anyhow::anyhow!("Rate limit exceeded"));
    }

    // Process request...
    Ok(())
}

/// Example 2: Rate limiting with different endpoint configurations
async fn example_endpoint_configs(rate_limiter: &RateLimiter) -> Result<()> {
    use api_gateway::routing::RateLimitConfig;

    // Configure high-frequency trading endpoint
    let trading_config = RateLimitConfig::trading_submit_order();
    rate_limiter.set_endpoint_config(trading_config).await;

    // Configure backtesting endpoint (low frequency)
    let backtesting_config = RateLimitConfig::backtesting_run();
    rate_limiter.set_endpoint_config(backtesting_config).await;

    // Configure custom endpoint
    let custom_config = RateLimitConfig {
        endpoint: "custom.api".to_string(),
        capacity: 50.0,
        refill_rate: 50.0,
        burst_size: 5,
    };
    rate_limiter.set_endpoint_config(custom_config).await;

    Ok(())
}

/// Example 3: Monitoring cache statistics
async fn example_monitoring(rate_limiter: &RateLimiter) -> Result<()> {
    // Get cache statistics
    let stats = rate_limiter.get_cache_stats().await;

    println!("Rate Limiter Cache Statistics:");
    println!("  Current size: {}/{}", stats.size, stats.max_size);
    println!("  Cache TTL: {} seconds", stats.ttl_seconds);
    println!("  Cache usage: {:.1}%",
             (stats.size as f64 / stats.max_size as f64) * 100.0);

    Ok(())
}

/// Example 4: Integration with gRPC interceptor
async fn example_grpc_integration(
    rate_limiter: &RateLimiter,
    user_id: &Uuid,
    request_uri: &str,
) -> Result<()> {
    // Extract endpoint from URI
    let endpoint = request_uri
        .split('/')
        .last()
        .unwrap_or("unknown");

    // Check rate limit
    if !rate_limiter.check_limit(user_id, endpoint).await? {
        // Log rate limit violation
        tracing::warn!(
            user_id = %user_id,
            endpoint = %endpoint,
            "Rate limit exceeded"
        );

        return Err(anyhow::anyhow!("Rate limit exceeded for {}", endpoint));
    }

    // Continue processing...
    Ok(())
}

/// Example 5: Burst handling scenario
async fn example_burst_handling(rate_limiter: &RateLimiter) -> Result<()> {
    let user_id = Uuid::new_v4();
    let endpoint = "trading.submit_order";

    // Simulate burst of 100 requests
    let mut allowed_count = 0;
    let mut denied_count = 0;

    for _ in 0..100 {
        if rate_limiter.check_limit(&user_id, endpoint).await? {
            allowed_count += 1;
        } else {
            denied_count += 1;
        }
    }

    println!("Burst test results:");
    println!("  Allowed: {} requests", allowed_count);
    println!("  Denied: {} requests", denied_count);

    // Should allow up to capacity (100 for trading endpoint)
    assert_eq!(allowed_count, 100);
    assert_eq!(denied_count, 0);

    Ok(())
}

/// Example 6: Cache management
async fn example_cache_management(rate_limiter: &RateLimiter) -> Result<()> {
    // Clear cache (useful after configuration changes)
    rate_limiter.clear_cache().await;

    println!("Cache cleared - all subsequent requests will hit Redis");

    // First request will populate cache from Redis
    let user_id = Uuid::new_v4();
    let _ = rate_limiter.check_limit(&user_id, "trading.submit_order").await?;

    println!("Cache populated - subsequent requests will be <50ns");

    Ok(())
}

/// Example 7: Performance testing
async fn example_performance_test(rate_limiter: &RateLimiter) -> Result<()> {
    use std::time::Instant;

    let user_id = Uuid::new_v4();
    let endpoint = "trading.submit_order";

    // Warm up cache
    let _ = rate_limiter.check_limit(&user_id, endpoint).await?;

    // Measure cache hit performance
    let iterations = 10_000;
    let start = Instant::now();

    for _ in 0..iterations {
        let _ = rate_limiter.check_limit(&user_id, endpoint).await?;
    }

    let elapsed = start.elapsed();
    let ns_per_check = elapsed.as_nanos() / iterations;

    println!("Performance test results:");
    println!("  Total time: {:?}", elapsed);
    println!("  Iterations: {}", iterations);
    println!("  Time per check: {} ns", ns_per_check);
    println!("  Target: <50ns");

    if ns_per_check < 50 {
        println!("  ✅ Performance target met!");
    } else {
        println!("  ⚠️ Performance target missed");
    }

    Ok(())
}

#[tokio::main]
async fn main() -> Result<()> {
    // Initialize rate limiter
    let rate_limiter = RateLimiter::new("redis://localhost:6379").await?;

    println!("Rate Limiter Usage Examples\n");

    // Run examples
    println!("Example 1: Basic auth flow");
    example_auth_flow(&rate_limiter, &Uuid::new_v4(), "trading.submit_order").await?;

    println!("\nExample 2: Endpoint configurations");
    example_endpoint_configs(&rate_limiter).await?;

    println!("\nExample 3: Monitoring");
    example_monitoring(&rate_limiter).await?;

    println!("\nExample 4: gRPC integration");
    example_grpc_integration(&rate_limiter, &Uuid::new_v4(), "/api/trading/submit_order").await?;

    println!("\nExample 5: Burst handling");
    example_burst_handling(&rate_limiter).await?;

    println!("\nExample 6: Cache management");
    example_cache_management(&rate_limiter).await?;

    println!("\nExample 7: Performance test");
    example_performance_test(&rate_limiter).await?;

    println!("\n✅ All examples completed successfully!");

    Ok(())
}