use std::collections::BTreeSet;

use crank_metrics::{
    HTTP_ROUTE_DOMAIN, HttpRoute, MAX_LOGICAL_SERIES_PER_PROCESS, MAX_PRODUCT_LABELS_PER_FAMILY,
    MAX_RENDERED_SERIES_PER_PROCESS, METRIC_SCHEMA_VERSION, metric_schema,
    render_metric_schema_json, schema_budget, validate_budget,
};

#[test]
fn schema_v1_is_complete_deterministic_and_inside_the_frozen_budget() {
    assert_eq!(METRIC_SCHEMA_VERSION, 1);
    assert_eq!(metric_schema().len(), 23);

    let budget = schema_budget().expect("canonical schema must be valid");
    assert!(budget.logical_series <= MAX_LOGICAL_SERIES_PER_PROCESS);
    assert!(budget.rendered_series <= MAX_RENDERED_SERIES_PER_PROCESS);

    for definition in metric_schema() {
        assert!(!definition.description.trim().is_empty());
        assert!(definition.labels.len() <= MAX_PRODUCT_LABELS_PER_FAMILY);
        assert!(!definition.processes.is_empty());
        assert_eq!(definition.labels.len(), definition.label_domains.len());
        assert!(definition.label_domains.iter().all(|domain| {
            !domain.values.is_empty()
                && domain.values.iter().all(|value| !value.is_empty())
                && domain.values.iter().copied().collect::<BTreeSet<_>>().len()
                    == domain.values.len()
        }));
        if definition.kind.as_str() == "histogram" {
            assert!(!definition.buckets.is_empty());
            assert!(definition.buckets.windows(2).all(|pair| pair[0] < pair[1]));
        } else {
            assert!(definition.buckets.is_empty());
        }
    }

    let first = render_metric_schema_json().expect("schema renders");
    let second = render_metric_schema_json().expect("schema renders deterministically");
    assert_eq!(first, second);
    assert!(first.len() < 65_536);
    assert!(!first.contains("trace_id"));
    assert!(!first.contains("request_id"));
}

#[test]
fn frozen_budget_edges_are_exact() {
    assert!(validate_budget(4_999, 14_999).is_ok());
    assert!(validate_budget(5_000, 15_000).is_ok());
    assert!(validate_budget(5_001, 15_000).is_err());
    assert!(validate_budget(5_000, 15_001).is_err());
    assert_eq!(crank_metrics::max_exemplar_slots(), 9_170);
}

#[test]
fn every_registered_route_round_trips_without_dynamic_segments() {
    assert_eq!(HTTP_ROUTE_DOMAIN.len(), 57);
    for route in HTTP_ROUTE_DOMAIN {
        assert_eq!(HttpRoute::from_matched_path(route).as_str(), *route);
        assert!(!route.contains("trace_id"));
        assert!(!route.contains("request_id"));
    }
}

#[test]
fn canonical_schema_validation_reports_its_category() {
    assert_eq!(
        schema_budget(),
        Ok(crank_metrics::SchemaBudget {
            logical_series: 4_513,
            rendered_series: 14_338
        })
    );
}

#[test]
fn exact_budget_math_counts_histogram_bucket_sum_and_count_series() {
    for definition in metric_schema() {
        let logical = definition
            .label_domains
            .iter()
            .map(|domain| domain.values.len())
            .product::<usize>();
        let logical = logical.max(1);
        let rendered = if definition.kind.as_str() == "histogram" {
            logical * (definition.buckets.len() + 3)
        } else {
            logical
        };
        assert_eq!(
            definition.max_logical_series, logical,
            "{}",
            definition.name
        );
        assert_eq!(
            definition.max_rendered_series, rendered,
            "{}",
            definition.name
        );
    }
}