mod dashboard_tests {
    use super::*;
    use http_body_util::BodyExt;
    async fn fill(cache: &Arc<Cache>, scope: &str, host: &str, path: &str) -> Ticket {
        let t = cache
            .ticket_scoped(
                7,
                scope,
                "http",
                host,
                "origin@127.0.0.1:8080",
                path,
                &HeaderMap::new(),
            )
            .unwrap();
        let settings = Settings {
            enabled: true,
            ..Settings::default()
        };
        let mut response = Response::new(Body::from("public representation"));
        response.headers_mut().insert(
            "cache-control",
            HeaderValue::from_static("public, max-age=30"),
        );
        response
            .headers_mut()
            .insert("vary", HeaderValue::from_static("Accept-Language"));
        let p = plan(
            StatusCode::OK,
            response.headers(),
            &settings,
            Duration::ZERO,
        )
        .unwrap();
        cache
            .wrap(response, t.clone(), p, &settings)
            .into_body()
            .collect()
            .await
            .unwrap();
        t
    }
    #[tokio::test]
    async fn dashboard_is_scoped_paginated_and_exposes_invalidation_identity_not_bodies() {
        let cache = Cache::new(7);
        let a = fill(&cache, "alpha", "a.example", "/data?private-query=secret").await;
        fill(&cache, "beta", "b.example", "/other").await;
        cache.record("alpha", "a.example", "MISS", "cache_miss");
        assert!(cache.get(&a).is_some());
        cache.record("alpha", "a.example", "HIT", "cache_hit");
        cache.record("alpha", "a.example", "BYPASS", "request_cookie");
        let d = cache.dashboard(Some("alpha"), 0, 50);
        assert_eq!(d.matching_objects, 1);
        assert_eq!(d.domains.len(), 1);
        assert_eq!(d.domains[0].counters.hits, 1);
        assert_eq!(d.domains[0].counters.stored, 1);
        assert_eq!(d.domains[0].counters.saved_body_bytes, 21);
        assert_eq!(d.objects[0].path, "/data");
        assert_eq!(d.objects[0].target, "/data?private-query=secret");
        assert_eq!(d.objects[0].cache_key.len(), 64);
        assert_eq!(d.objects[0].hits, 1);
        let encoded = serde_json::to_string(&d).unwrap();
        assert!(encoded.contains("private-query=secret"));
        assert!(!encoded.contains("public representation"));
        assert_eq!(cache.dashboard(None, 1, 1).objects.len(), 1);
        assert_eq!(cache.dashboard(None, 99, 999).limit, 200);
        assert_eq!(cache.purge_scope("alpha"), 1);
        assert_eq!(cache.dashboard(Some("beta"), 0, 50).matching_objects, 1);
        assert_eq!(
            cache.dashboard(Some("alpha"), 0, 50).domains[0]
                .counters
                .hits,
            1
        );
        cache.purge(Some(8));
        assert!(cache.dashboard(None, 0, 50).domains.is_empty());
    }
    #[tokio::test]
    async fn dashboard_retains_expired_entries_for_client_max_stale() {
        let cache = Cache::new(7);
        let ticket = fill(&cache, "a", "a.example", "/").await;
        {
            let mut store = cache.store.lock().unwrap();
            for entry in store.entries.values_mut() {
                entry.received = Instant::now() - Duration::from_secs(2 * 60 * 60);
            }
        }
        let dashboard = cache.dashboard(None, 0, 50);
        assert_eq!(dashboard.matching_objects, 1);
        assert_eq!(dashboard.objects[0].remaining_ttl_seconds, 0);
        assert!(dashboard.objects[0].age_seconds >= 2 * 60 * 60);
        assert_eq!(cache.view().entries, 1);
        assert_eq!(cache.view().expired, 0);
        assert!(
            cache.get(&ticket).is_none(),
            "inventory visibility cannot permit unconditional stale delivery"
        );
        let mut stale = ticket;
        stale
            .request_headers
            .insert("cache-control", HeaderValue::from_static("max-stale"));
        assert!(cache.get(&stale).unwrap().stale);
    }
    #[test]
    fn bypass_reasons_are_fixed_and_private_inputs_are_not_echoed() {
        let settings = Settings {
            varnish_compatible: false,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        headers.insert("cookie", HeaderValue::from_static("session=very-private"));
        assert_eq!(
            request_reason(&Method::GET, &headers, true, "/", false, &settings),
            Some("request_cookie")
        );
        headers.remove("cookie");
        headers.insert("cache-control", HeaderValue::from_static("no-cache"));
        assert_eq!(
            request_reason(&Method::GET, &headers, true, "/", false, &settings),
            None
        );
        assert_eq!(
            request_policy(&Method::GET, &headers, true, "/", false, &settings),
            RequestPolicy::Revalidate("request_no_cache")
        );
        let diagnostics = Settings {
            expose_status: true,
            expose_cache_status: true,
            ..settings
        };
        diagnostics.annotate_reason_transformed(
            &mut headers,
            "BYPASS",
            0,
            0,
            "request_cookie",
            true,
        );
        assert_eq!(headers["x-cache-reason"], "request_cookie");
        assert_eq!(
            headers["cache-status"],
            "RustProxy; fwd=bypass; detail=\"request_cookie\"; transformed"
        );
    }
    #[test]
    fn hit_only_cache_diagnostics_hides_miss_bypass_and_preserves_hits() {
        let global = Settings {
            expose_status: true,
            expose_hits: true,
            expose_cache_status: true,
            expose_resident_age: true,
            expose_only_hits: true,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        headers.insert("x-cache", HeaderValue::from_static("untrusted-upstream"));
        headers.insert("cache-status", HeaderValue::from_static("Origin; hit"));
        global.annotate_reason_transformed(
            &mut headers,
            "MISS",
            0,
            0,
            "response_headers_policy",
            true,
        );
        assert_eq!(headers["x-cache"], "untrusted-upstream");
        assert_eq!(headers["cache-status"], "Origin; hit");
        assert!(!headers.contains_key("x-cache-hits"));
        assert!(!headers.contains_key("x-cache-reason"));
        assert_eq!(headers["via"], "RustProxy");
        global.annotate_reason(&mut headers, "BYPASS", 0, 0, "request_cookie");
        assert_eq!(headers.get_all("cache-status").iter().count(), 1);
        global.annotate_reason(&mut headers, "HIT", 4, 60, "cache_hit");
        global.annotate_resident_age(&mut headers, 10);
        assert_eq!(headers["x-cache"], "HIT");
        assert_eq!(headers["x-cache-hits"], "4");
        let chain: Vec<_> = headers
            .get_all("cache-status")
            .iter()
            .map(|value| value.to_str().unwrap())
            .collect();
        assert_eq!(
            chain,
            vec![
                "Origin; hit",
                "RustProxy; hit; ttl=60; detail=\"cache_hit\""
            ]
        );
        assert_eq!(headers["x-upstream-cache"], "untrusted-upstream");
        assert_eq!(headers["x-cache-resident-age"], "10");
        let mut override_on = Overrides {
            expose_only_hits: Some(false),
            ..Default::default()
        };
        let normal = override_on.resolve(&global).unwrap();
        assert!(!normal.expose_only_hits);
        override_on.expose_only_hits = Some(true);
        assert!(
            override_on
                .resolve(&Settings::default())
                .unwrap()
                .expose_only_hits
        );
    }
    #[test]
    fn via_header_is_configurable_and_preserves_upstream_chain() {
        let settings = Settings::default();
        let mut headers = HeaderMap::new();
        headers.append("via", HeaderValue::from_static("1.1 upstream"));
        settings.annotate(&mut headers, "HIT", 1, 20);
        let values: Vec<_> = headers
            .get_all("via")
            .iter()
            .map(|value| value.to_str().unwrap())
            .collect();
        assert_eq!(values, vec!["1.1 upstream", "RustProxy"]);

        let disabled = Settings {
            via_header: None,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        disabled.annotate(&mut headers, "MISS", 0, 0);
        assert!(!headers.contains_key("via"));
    }

    #[test]
    fn disabled_cache_forwards_origin_diagnostics_unchanged() {
        let settings = Settings {
            enabled: false,
            expose_status: true,
            expose_hits: true,
            expose_cache_status: true,
            expose_resident_age: true,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        headers.insert("x-cache", HeaderValue::from_static("origin"));
        headers.insert("x-cache-hits", HeaderValue::from_static("99"));
        headers.insert("x-cache-status", HeaderValue::from_static("origin"));
        headers.insert("cache-status", HeaderValue::from_static("Origin; hit"));
        headers.insert("x-cache-reason", HeaderValue::from_static("origin"));
        headers.insert("x-cache-resident-age", HeaderValue::from_static("5"));
        settings.annotate_reason(&mut headers, "BYPASS", 0, 0, "cache_disabled");
        settings.annotate_resident_age(&mut headers, 9);
        assert_eq!(headers["x-cache"], "origin");
        assert_eq!(headers["x-cache-hits"], "99");
        assert_eq!(headers["x-cache-status"], "origin");
        assert_eq!(headers["cache-status"], "Origin; hit");
        assert_eq!(headers["x-cache-reason"], "origin");
        assert_eq!(headers["x-cache-resident-age"], "5");
        assert!(!headers.contains_key("x-upstream-cache"));
        assert!(!headers.contains_key("via"));
    }

    #[test]
    fn chain_and_legacy_header_collisions_keep_origin_values() {
        let settings = Settings {
            expose_status: true,
            expose_hits: true,
            expose_cache_status: true,
            expose_resident_age: true,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        headers.append(
            "cache-status",
            HeaderValue::from_static("Inner; hit; ttl=100"),
        );
        headers.append("cache-status", HeaderValue::from_static("Shield; fwd=miss"));
        for (name, value) in [
            ("x-cache", "BACKEND-MISS"),
            ("x-cache-hits", "21"),
            ("x-cache-reason", "origin_reason"),
            ("x-cache-resident-age", "17"),
            ("x-cache-status", "backend-status"),
        ] {
            headers.insert(name, value.parse().unwrap());
        }
        settings.annotate_reason_transformed(&mut headers, "HIT", 3, 482, "cache_hit", true);
        settings.annotate_resident_age(&mut headers, 9);
        let cache_chain: Vec<_> = headers
            .get_all("cache-status")
            .iter()
            .map(|value| value.to_str().unwrap())
            .collect();
        assert_eq!(
            cache_chain,
            vec![
                "Inner; hit; ttl=100",
                "Shield; fwd=miss",
                "RustProxy; hit; ttl=482; detail=\"cache_hit\"; transformed",
            ]
        );
        assert_eq!(headers["x-cache"], "HIT");
        assert_eq!(headers["x-upstream-cache"], "BACKEND-MISS");
        assert_eq!(headers["x-cache-hits"], "3");
        assert_eq!(headers["x-upstream-cache-hits"], "21");
        assert_eq!(headers["x-cache-reason"], "cache_hit");
        assert_eq!(headers["x-upstream-cache-reason"], "origin_reason");
        assert_eq!(headers["x-cache-resident-age"], "9");
        assert_eq!(headers["x-upstream-cache-resident-age"], "17");
        assert_eq!(headers["x-cache-status"], "backend-status");
    }

    #[test]
    fn diagnostic_options_do_not_hide_backend_cache_status() {
        for (enabled, status, only_hits) in [
            (true, false, false),
            (true, true, true),
            (false, true, false),
        ] {
            let settings = Settings {
                enabled,
                expose_status: status,
                expose_cache_status: status,
                expose_only_hits: only_hits,
                ..Settings::default()
            };
            let mut headers = HeaderMap::new();
            headers.insert("x-cache", HeaderValue::from_static("Backend; MISS"));
            headers.insert("cache-status", HeaderValue::from_static("Origin; fwd=miss"));
            settings.annotate_reason_transformed(&mut headers, "MISS", 0, 0, "cache_miss", true);
            assert_eq!(headers["x-cache"], "Backend; MISS");
            assert_eq!(headers["cache-status"], "Origin; fwd=miss");
            assert_eq!(headers.get_all("cache-status").iter().count(), 1);
            assert!(!headers.contains_key("x-upstream-cache"));
        }
    }

    #[test]
    fn repeated_upstream_legacy_values_are_not_collapsed_or_discarded() {
        let settings = Settings {
            expose_status: true,
            expose_cache_status: true,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        headers.append("x-cache", HeaderValue::from_static("inner-HIT"));
        headers.append("x-cache", HeaderValue::from_static("outer-MISS"));
        headers.append("cache-status", HeaderValue::from_static("Inner; hit"));
        headers.append("cache-status", HeaderValue::from_static("Outer; fwd=miss"));
        settings.annotate_reason(&mut headers, "MISS", 0, 0, "cache_miss");
        let upstream_values: Vec<_> = headers
            .get_all("x-upstream-cache")
            .iter()
            .map(|value| value.to_str().unwrap())
            .collect();
        assert_eq!(upstream_values, vec!["inner-HIT", "outer-MISS"]);
        assert_eq!(headers["x-cache"], "MISS");
        let status_chain: Vec<_> = headers
            .get_all("cache-status")
            .iter()
            .map(|value| value.to_str().unwrap())
            .collect();
        assert_eq!(
            status_chain,
            vec![
                "Inner; hit",
                "Outer; fwd=miss",
                "RustProxy; fwd=miss; detail=\"cache_miss\"",
            ]
        );
    }

    #[test]
    fn client_no_cache_miss_does_not_claim_a_fresh_candidate() {
        let settings = Settings {
            expose_cache_status: true,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        settings.annotate_reason(&mut headers, "MISS", 0, 0, "request_no_cache");
        assert_eq!(
            headers["cache-status"],
            "RustProxy; fwd=miss; detail=\"request_no_cache\"",
        );
    }

    #[test]
    fn revalidated_304_is_forwarded_under_rfc_9211_even_if_legacy_x_cache_is_hit() {
        let settings = Settings {
            expose_status: true,
            expose_cache_status: true,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        headers.insert("cache-status", HeaderValue::from_static("Origin; hit"));
        settings.annotate_reason_transformed(
            &mut headers,
            "HIT",
            2,
            50,
            "cache_revalidated",
            false,
        );
        assert_eq!(headers["x-cache"], "HIT");
        let chain: Vec<_> = headers
            .get_all("cache-status")
            .iter()
            .map(|v| v.to_str().unwrap())
            .collect();
        assert_eq!(
            chain,
            vec![
                "Origin; hit",
                "RustProxy; fwd=stale; fwd-status=304; detail=\"cache_revalidated\"",
            ]
        );
    }

    #[test]
    fn rfc9211_method_bypass_and_stale_hit_do_not_misstate_freshness() {
        assert_eq!(cache_status_ttl(1, 2), -1);
        assert_eq!(cache_status_ttl(10, 10), 0);
        assert_eq!(cache_status_ttl(600, 5), 595);
        let settings = Settings {
            expose_status: true,
            expose_cache_status: true,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        settings.annotate_reason(&mut headers, "BYPASS", 0, 0, "request_method");
        assert_eq!(
            headers["cache-status"],
            "RustProxy; fwd=method; detail=\"request_method\"",
        );
        let mut headers = HeaderMap::new();
        settings.annotate_reason_transformed_freshness(
            &mut headers,
            "HIT",
            3,
            -7,
            "cache_max_stale",
            false,
        );
        assert_eq!(
            headers["cache-status"],
            "RustProxy; hit; ttl=-7; detail=\"cache_max_stale\"",
        );
        let mut headers = HeaderMap::new();
        settings.annotate_reason_transformed_freshness(
            &mut headers,
            "HIT",
            3,
            -5,
            "cache_stale_while_revalidate",
            false,
        );
        assert_eq!(
            headers["cache-status"],
            "RustProxy; hit; ttl=-5; detail=\"cache_stale_while_revalidate\"",
        );
    }

    #[test]
    fn rfc9211_forwarded_stale_error_and_forced_validation_report_real_hops() {
        let settings = Settings {
            expose_status: true,
            expose_cache_status: true,
            ..Settings::default()
        };
        let mut headers = HeaderMap::new();
        headers.append("cache-status", HeaderValue::from_static("OriginCache; hit"));
        settings.annotate_reason_transformed_forwarded(
            &mut headers,
            "HIT",
            3,
            0,
            "cache_stale_if_error",
            false,
            "stale",
            Some(StatusCode::SERVICE_UNAVAILABLE),
        );
        assert_eq!(headers["x-cache"], "HIT");
        let values: Vec<_> = headers
            .get_all("cache-status")
            .iter()
            .map(|value| value.to_str().unwrap())
            .collect();
        assert_eq!(
            values,
            vec![
                "OriginCache; hit",
                "RustProxy; fwd=stale; fwd-status=503; detail=\"cache_stale_if_error\"",
            ]
        );
        let mut headers = HeaderMap::new();
        settings.annotate_reason_transformed_forwarded(
            &mut headers,
            "HIT",
            2,
            42,
            "cache_revalidated",
            false,
            "request",
            Some(StatusCode::NOT_MODIFIED),
        );
        assert_eq!(
            headers["cache-status"],
            "RustProxy; fwd=request; fwd-status=304; detail=\"cache_revalidated\"",
        );
        let mut headers = HeaderMap::new();
        settings.annotate_reason_transformed_forwarded(
            &mut headers,
            "HIT",
            2,
            0,
            "cache_stale_if_error",
            false,
            "stale",
            None,
        );
        assert_eq!(
            headers["cache-status"],
            "RustProxy; fwd=stale; detail=\"cache_stale_if_error\"",
        );
    }

    #[test]
    fn cache_domain_metrics_do_not_lock_hot_store_and_preserve_reasons() {
        let cache = Cache::new(7);
        let store = cache.store.lock().unwrap();
        cache.record("alpha", "a.example", "BYPASS", "cache_disabled");
        cache.record_reason("alpha", "a.example", "background_refresh_failure");
        drop(store);
        let workers = 8;
        let each = 2000;
        let mut tasks = Vec::new();
        for _ in 0..workers {
            let cache = Arc::clone(&cache);
            tasks.push(std::thread::spawn(move || {
                for _ in 0..each {
                    cache.record("alpha", "a.example", "BYPASS", "cache_disabled");
                    cache.record("alpha", "a.example", "HIT", "cache_hit");
                }
            }));
        }
        for task in tasks {
            task.join().expect("domain counter worker");
        }
        let scoped = cache.dashboard(Some("alpha"), 0, 1);
        assert_eq!(scoped.domains.len(), 1);
        let counters = &scoped.domains[0].counters;
        assert_eq!(counters.bypasses, 1 + workers * each);
        assert_eq!(counters.hits, workers * each);
        assert_eq!(counters.reasons["cache_disabled"], 1 + workers * each);
        assert_eq!(counters.reasons["cache_hit"], workers * each);
        assert_eq!(counters.reasons["background_refresh_failure"], 1);
        assert_eq!(cache.purge_scope("alpha"), 0);
        assert_eq!(
            cache.dashboard(Some("alpha"), 0, 1).domains[0]
                .counters
                .hits,
            workers * each
        );
        cache.purge(Some(8));
        assert!(cache.dashboard(None, 0, 1).domains.is_empty());
        cache.record("alpha", "a.example", "MISS", "cache_miss");
        let after_reset = cache.dashboard(Some("alpha"), 0, 1);
        assert_eq!(after_reset.domains[0].counters.misses, 1);
        assert_eq!(after_reset.domains[0].counters.hits, 0);
        assert_eq!(after_reset.statistics_revision, 8);
    }

    #[test]
    fn first_hit_saved_bytes_registers_domain_even_without_prior_record() {
        let cache = Cache::new(7);
        cache
            .domain_stats
            .saved_body_hit("cold", "restored.example", 1040);
        let result = cache.dashboard(Some("cold"), 0, 1);
        assert_eq!(result.domains.len(), 1);
        assert_eq!(result.domains[0].counters.saved_body_bytes, 1040);
    }

    #[test]
    fn per_domain_counter_cardinality_is_bounded() {
        let cache = Cache::new(7);
        for i in 0..5000 {
            cache.record(
                "legacy",
                &format!("{i}.example"),
                "BYPASS",
                "cache_disabled",
            );
        }
        assert_eq!(cache.dashboard(None, 0, 1).domains.len(), 4096);
    }
}