use std::{
    hint::black_box,
    time::{Duration, Instant},
};

use crank_metrics::{CacheOutcome, record_cache_outcome};
use metrics_util::debugging::DebuggingRecorder;

const SAMPLES: usize = 40;
const WORK_UNITS: u64 = 500_000;

#[test]
fn reproducible_foundation_profile_stays_inside_latency_and_cpu_proxy_budgets() {
    let recorder = DebuggingRecorder::new();
    let snapshotter = recorder.snapshotter();
    let mut baseline = Vec::with_capacity(SAMPLES);
    let mut enabled = Vec::with_capacity(SAMPLES);

    metrics::with_local_recorder(&recorder, || {
        for index in 0..SAMPLES {
            if index % 2 == 0 {
                baseline.push(sample(false));
                enabled.push(sample(true));
            } else {
                enabled.push(sample(true));
                baseline.push(sample(false));
            }
        }
    });

    baseline.sort_unstable();
    enabled.sort_unstable();
    let baseline_p95 = baseline[SAMPLES * 95 / 100];
    let enabled_p95 = enabled[SAMPLES * 95 / 100];
    let baseline_cpu: Duration = baseline.iter().copied().sum();
    let enabled_cpu: Duration = enabled.iter().copied().sum();
    let series = snapshotter.snapshot().into_vec().len();

    println!(
        "metrics_profile_v1 samples={SAMPLES} work_units={WORK_UNITS} baseline_p95_ns={} enabled_p95_ns={} baseline_cpu_ns={} enabled_cpu_ns={} logical_series={series}",
        baseline_p95.as_nanos(),
        enabled_p95.as_nanos(),
        baseline_cpu.as_nanos(),
        enabled_cpu.as_nanos()
    );
    assert!(enabled_p95.as_nanos() * 100 <= baseline_p95.as_nanos() * 105);
    assert!(enabled_cpu.as_nanos() * 100 <= baseline_cpu.as_nanos() * 110);
    assert_eq!(series, 1);
}

fn sample(with_metrics: bool) -> Duration {
    let started = Instant::now();
    let mut value = 0x9e37_79b9_u64;
    for index in 0..WORK_UNITS {
        value = value.rotate_left(7) ^ index.wrapping_mul(0x100_0000_01b3);
    }
    black_box(value);
    if with_metrics {
        record_cache_outcome(CacheOutcome::Hit);
    }
    started.elapsed()
}