//! Comprehensive benchmark suite for RTX-Eval performance measurement
//!
//! This benchmark measures the performance of the RTX-Eval framework itself,
//! ensuring that the benchmarking system is efficient and can handle large-scale evaluations.

use criterion::{BenchmarkId, Criterion, Throughput, black_box, criterion_group, criterion_main};
use rtx_eval::benchmarks::*;
use rtx_eval::*;
use std::time::Duration;
use tokio::runtime::Runtime;

fn benchmark_evaluation_overhead(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("evaluation_overhead");

    // Test different numbers of benchmarks
    for num_benchmarks in [1, 5, 10, 25].iter() {
        let config = EvalConfig {
            categories: vec![BenchmarkCategory::Performance],
            timeout: Duration::from_secs(30),
            num_workers: 1,
            ..Default::default()
        };

        group.throughput(Throughput::Elements(*num_benchmarks as u64));
        group.bench_with_input(
            BenchmarkId::new("benchmark_execution", num_benchmarks),
            num_benchmarks,
            |b, &num_benchmarks| {
                b.to_async(&rt).iter(|| async {
                    let mut evaluator = RTXEvaluator::with_config(config.clone()).unwrap();

                    // Simulate running multiple benchmarks
                    for _ in 0..num_benchmarks {
                        let _ = black_box(evaluator.run_performance_benchmarks().await);
                    }
                });
            },
        );
    }

    group.finish();
}

fn benchmark_metrics_calculation(c: &mut Criterion) {
    let config = EvalConfig::default();
    let metrics_engine = MetricsEngine::new(&config).unwrap();

    let mut group = c.benchmark_group("metrics_calculation");

    // Test different data sizes
    for data_size in [100, 1000, 10000, 100000].iter() {
        let predictions: Vec<f64> = (0..*data_size)
            .map(|i| (i as f64) / (*data_size as f64))
            .collect();
        let targets: Vec<f64> = (0..*data_size)
            .map(|i| ((i + 1) as f64) / (*data_size as f64))
            .collect();

        group.throughput(Throughput::Elements(*data_size as u64));
        group.bench_with_input(
            BenchmarkId::new("calculate_metrics", data_size),
            data_size,
            |b, _| {
                b.iter(|| {
                    black_box(metrics_engine.calculate_metrics(
                        "benchmark_test",
                        &predictions,
                        &targets,
                    ));
                });
            },
        );
    }

    group.finish();
}

fn benchmark_language_benchmarks(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("language_benchmarks");
    group.measurement_time(Duration::from_secs(30));

    // Test individual language benchmarks
    let benchmarks = [
        ("GLUE", Box::new(GlueBenchmark::new()) as Box<dyn Benchmark>),
        (
            "SuperGLUE",
            Box::new(SuperGlueBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "HellaSwag",
            Box::new(HellaSwagBenchmark::new()) as Box<dyn Benchmark>,
        ),
        ("ARC", Box::new(ArcBenchmark::new()) as Box<dyn Benchmark>),
        (
            "GSM8K",
            Box::new(Gsm8kBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "HumanEval",
            Box::new(HumanEvalBenchmark::new()) as Box<dyn Benchmark>,
        ),
    ];

    for (name, mut benchmark) in benchmarks {
        group.bench_function(name, |b| {
            b.to_async(&rt).iter(|| async {
                let config = BenchmarkConfig::default();
                let _ = benchmark.setup().await;
                let result = black_box(benchmark.run(&config).await);
                let _ = benchmark.cleanup().await;
                result
            });
        });
    }

    group.finish();
}

fn benchmark_vision_benchmarks(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("vision_benchmarks");
    group.measurement_time(Duration::from_secs(30));

    let benchmarks = [
        (
            "ImageNet",
            Box::new(ImageNetBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "COCO-Detection",
            Box::new(CocoBenchmark::new(CocoTask::Detection)) as Box<dyn Benchmark>,
        ),
        (
            "Open-Images",
            Box::new(OpenImagesBenchmark::new()) as Box<dyn Benchmark>,
        ),
        ("LVIS", Box::new(LvisBenchmark::new()) as Box<dyn Benchmark>),
    ];

    for (name, mut benchmark) in benchmarks {
        group.bench_function(name, |b| {
            b.to_async(&rt).iter(|| async {
                let config = BenchmarkConfig::default();
                let _ = benchmark.setup().await;
                let result = black_box(benchmark.run(&config).await);
                let _ = benchmark.cleanup().await;
                result
            });
        });
    }

    group.finish();
}

fn benchmark_multimodal_benchmarks(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("multimodal_benchmarks");
    group.measurement_time(Duration::from_secs(30));

    let benchmarks = [
        (
            "VQA-v2",
            Box::new(VqaBenchmark::new(VqaVersion::V2)) as Box<dyn Benchmark>,
        ),
        ("CLIP", Box::new(ClipBenchmark::new()) as Box<dyn Benchmark>),
        (
            "Flickr30K",
            Box::new(Flickr30kBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "TextVQA",
            Box::new(TextVqaBenchmark::new()) as Box<dyn Benchmark>,
        ),
    ];

    for (name, mut benchmark) in benchmarks {
        group.bench_function(name, |b| {
            b.to_async(&rt).iter(|| async {
                let config = BenchmarkConfig::default();
                let _ = benchmark.setup().await;
                let result = black_box(benchmark.run(&config).await);
                let _ = benchmark.cleanup().await;
                result
            });
        });
    }

    group.finish();
}

fn benchmark_scientific_benchmarks(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("scientific_benchmarks");
    group.measurement_time(Duration::from_secs(30));

    let benchmarks = [
        ("MATH", Box::new(MathBenchmark::new()) as Box<dyn Benchmark>),
        (
            "TheoremQA",
            Box::new(TheoremQaBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "PubMedQA",
            Box::new(PubMedQaBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "ScienceQA",
            Box::new(ScienceQaBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "MoleculeNet",
            Box::new(MoleculeNetBenchmark::new()) as Box<dyn Benchmark>,
        ),
    ];

    for (name, mut benchmark) in benchmarks {
        group.bench_function(name, |b| {
            b.to_async(&rt).iter(|| async {
                let config = BenchmarkConfig::default();
                let _ = benchmark.setup().await;
                let result = black_box(benchmark.run(&config).await);
                let _ = benchmark.cleanup().await;
                result
            });
        });
    }

    group.finish();
}

fn benchmark_performance_benchmarks(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("performance_benchmarks");
    group.measurement_time(Duration::from_secs(20));

    let benchmarks = [
        (
            "Throughput",
            Box::new(ThroughputBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "Latency",
            Box::new(LatencyBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "Memory-Efficiency",
            Box::new(MemoryBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "Scalability",
            Box::new(ScalabilityBenchmark::new()) as Box<dyn Benchmark>,
        ),
    ];

    for (name, mut benchmark) in benchmarks {
        group.bench_function(name, |b| {
            b.to_async(&rt).iter(|| async {
                let config = BenchmarkConfig::default();
                let _ = benchmark.setup().await;
                let result = black_box(benchmark.run(&config).await);
                let _ = benchmark.cleanup().await;
                result
            });
        });
    }

    group.finish();
}

fn benchmark_robustness_benchmarks(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("robustness_benchmarks");
    group.measurement_time(Duration::from_secs(30));

    let benchmarks = [
        (
            "Adversarial-Robustness",
            Box::new(AdversarialRobustnessBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "OOD-Detection",
            Box::new(OodDetectionBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "Fairness",
            Box::new(FairnessBenchmark::new()) as Box<dyn Benchmark>,
        ),
        (
            "Calibration",
            Box::new(CalibrationBenchmark::new()) as Box<dyn Benchmark>,
        ),
    ];

    for (name, mut benchmark) in benchmarks {
        group.bench_function(name, |b| {
            b.to_async(&rt).iter(|| async {
                let config = BenchmarkConfig::default();
                let _ = benchmark.setup().await;
                let result = black_box(benchmark.run(&config).await);
                let _ = benchmark.cleanup().await;
                result
            });
        });
    }

    group.finish();
}

fn benchmark_comprehensive_evaluation(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("comprehensive_evaluation");
    group.measurement_time(Duration::from_secs(60));
    group.sample_size(10);

    // Test different evaluation configurations
    let configs = [
        (
            "minimal",
            EvalConfig {
                categories: vec![BenchmarkCategory::Performance],
                timeout: Duration::from_secs(10),
                ..Default::default()
            },
        ),
        (
            "standard",
            EvalConfig {
                categories: vec![
                    BenchmarkCategory::Language,
                    BenchmarkCategory::Vision,
                    BenchmarkCategory::Performance,
                ],
                timeout: Duration::from_secs(20),
                ..Default::default()
            },
        ),
        (
            "comprehensive",
            EvalConfig {
                categories: vec![
                    BenchmarkCategory::Language,
                    BenchmarkCategory::Vision,
                    BenchmarkCategory::Multimodal,
                    BenchmarkCategory::Scientific,
                    BenchmarkCategory::Performance,
                    BenchmarkCategory::Robustness,
                ],
                timeout: Duration::from_secs(30),
                ..Default::default()
            },
        ),
    ];

    for (name, config) in configs {
        group.bench_function(name, |b| {
            b.to_async(&rt).iter(|| async {
                let mut evaluator = RTXEvaluator::with_config(config.clone()).unwrap();
                black_box(evaluator.run_comprehensive_evaluation().await)
            });
        });
    }

    group.finish();
}

fn benchmark_automation_system(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("automation_system");
    group.measurement_time(Duration::from_secs(20));

    group.bench_function("ci_benchmark_execution", |b| {
        b.to_async(&rt).iter(|| async {
            let config = AutomationConfig::default();
            let automation = BenchmarkAutomation::new(config).unwrap();
            black_box(
                automation
                    .execute_ci_benchmarks(CiTrigger::PullRequest)
                    .await,
            )
        });
    });

    group.bench_function("automation_report_generation", |b| {
        b.to_async(&rt).iter(|| async {
            let config = AutomationConfig::default();
            let automation = BenchmarkAutomation::new(config).unwrap();
            black_box(automation.generate_automation_report().await)
        });
    });

    group.finish();
}

fn benchmark_validation_system(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("validation_system");
    group.measurement_time(Duration::from_secs(30));

    // Create mock RTX results for validation
    let create_mock_results = || {
        use std::collections::HashMap;
        let mut results = HashMap::new();
        results.insert(
            "test".to_string(),
            crate::core::BenchmarkResults {
                category: BenchmarkCategory::Performance,
                results: vec![crate::core::BenchmarkResult {
                    benchmark_name: "TestBenchmark".to_string(),
                    category: BenchmarkCategory::Performance,
                    start_time: chrono::Utc::now(),
                    duration: Duration::from_secs(1),
                    success: true,
                    metrics: {
                        let mut metrics = HashMap::new();
                        metrics.insert("accuracy".to_string(), 0.85);
                        metrics.insert("throughput".to_string(), 1000.0);
                        metrics.insert("latency".to_string(), 25.0);
                        metrics
                    },
                    metadata: HashMap::new(),
                    error_message: None,
                }],
                summary: crate::core::BenchmarkSummary {
                    total_benchmarks: 1,
                    successful_benchmarks: 1,
                    failed_benchmarks: 0,
                    total_duration: Duration::from_secs(1),
                    average_accuracy: 0.85,
                    performance_score: 1.2,
                },
                timestamp: chrono::Utc::now(),
            },
        );
        results
    };

    group.bench_function("comprehensive_validation", |b| {
        b.to_async(&rt).iter(|| async {
            let config = ValidationConfig {
                enable_competitor_comparison: false, // Disabled for benchmarking
                reproducibility_runs: 3,             // Reduced for benchmarking
                cross_platform: false,               // Disabled for benchmarking
                ..Default::default()
            };
            let validation_suite = ValidationSuite::new(config).unwrap();
            let mock_results = create_mock_results();
            black_box(
                validation_suite
                    .run_comprehensive_validation(&mock_results)
                    .await,
            )
        });
    });

    group.finish();
}

fn benchmark_concurrent_execution(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("concurrent_execution");
    group.measurement_time(Duration::from_secs(30));

    // Test different levels of concurrency
    for concurrency in [1, 2, 4, 8].iter() {
        group.throughput(Throughput::Elements(*concurrency as u64));
        group.bench_with_input(
            BenchmarkId::new("concurrent_benchmarks", concurrency),
            concurrency,
            |b, &concurrency| {
                b.to_async(&rt).iter(|| async {
                    let mut handles = vec![];

                    for _ in 0..concurrency {
                        let handle = tokio::spawn(async {
                            let config = EvalConfig {
                                categories: vec![BenchmarkCategory::Performance],
                                timeout: Duration::from_secs(5),
                                ..Default::default()
                            };
                            let mut evaluator = RTXEvaluator::with_config(config).unwrap();
                            evaluator.run_performance_benchmarks().await
                        });
                        handles.push(handle);
                    }

                    // Wait for all to complete
                    for handle in handles {
                        let _ = black_box(handle.await);
                    }
                });
            },
        );
    }

    group.finish();
}

fn benchmark_memory_usage(c: &mut Criterion) {
    let rt = Runtime::new().unwrap();

    let mut group = c.benchmark_group("memory_usage");
    group.measurement_time(Duration::from_secs(20));

    // Test memory usage with different numbers of benchmarks
    for num_benchmarks in [1, 5, 10, 20].iter() {
        group.throughput(Throughput::Elements(*num_benchmarks as u64));
        group.bench_with_input(
            BenchmarkId::new("memory_scaling", num_benchmarks),
            num_benchmarks,
            |b, &num_benchmarks| {
                b.to_async(&rt).iter(|| async {
                    let mut evaluators = Vec::new();

                    // Create multiple evaluators to test memory scaling
                    for _ in 0..num_benchmarks {
                        let config = EvalConfig {
                            categories: vec![BenchmarkCategory::Performance],
                            timeout: Duration::from_secs(1),
                            ..Default::default()
                        };
                        let evaluator = RTXEvaluator::with_config(config).unwrap();
                        evaluators.push(evaluator);
                    }

                    // Run a quick benchmark on each
                    for mut evaluator in evaluators {
                        let _ = black_box(evaluator.get_rtx_baseline_performance().await);
                    }
                });
            },
        );
    }

    group.finish();
}

criterion_group!(
    benches,
    benchmark_evaluation_overhead,
    benchmark_metrics_calculation,
    benchmark_language_benchmarks,
    benchmark_vision_benchmarks,
    benchmark_multimodal_benchmarks,
    benchmark_scientific_benchmarks,
    benchmark_performance_benchmarks,
    benchmark_robustness_benchmarks,
    benchmark_comprehensive_evaluation,
    benchmark_automation_system,
    benchmark_validation_system,
    benchmark_concurrent_execution,
    benchmark_memory_usage,
);

criterion_main!(benches);