use std::fs;
use std::path::PathBuf;

use rpki::rtr::loader::{ParsedAspa, ParsedVrp};
use tempfile::tempdir;
use rpki::source::ccr::{find_latest_ccr_file, load_ccr_snapshot_from_file,
                        snapshot_to_payloads_with_options, ParsedCcrSnapshot};

fn fixture_path(name: &str) -> PathBuf {
    PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("data").join(name)
}

#[test]
#[ignore = "manual CCR loader smoke test for local samples"]
fn ccr_loader_smoke() {
    let snapshot = load_ccr_snapshot_from_file(fixture_path("20260324T000037Z-sng1.ccr"))
        .expect("load CCR snapshot");

    println!("content_type_oid: {}", snapshot.content_type_oid);
    println!("produced_at     : {:?}", snapshot.produced_at);
    println!("vrp_count       : {}", snapshot.vrps.len());
    println!("vap_count       : {}", snapshot.vaps.len());
    println!("first_vrp       : {:?}", snapshot.vrps.first());
    println!("first_vap       : {:?}", snapshot.vaps.first());
}

#[test]
fn find_latest_ccr_file_picks_latest_name() {
    let dir = tempdir().expect("create temp dir");
    let older = dir.path().join("20260324T000037Z-sng1.ccr");
    let newer = dir.path().join("20260324T000138Z-zur1.ccr");
    let ignored = dir.path().join("notes.txt");

    fs::write(&older, b"older").expect("write older ccr");
    fs::write(&newer, b"newer").expect("write newer ccr");
    fs::write(&ignored, b"ignored").expect("write ignored file");

    let latest = find_latest_ccr_file(dir.path()).expect("find latest ccr");

    assert_eq!(latest, newer);
}

#[test]
fn snapshot_to_payloads_with_options_skips_invalid_aspa_when_not_strict() {
    let snapshot = ParsedCcrSnapshot {
        content_type_oid: "1.2.840.113549.1.9.16.1.54".to_string(),
        produced_at: Some("20260324000037Z".to_string()),
        vrps: vec![ParsedVrp {
            prefix_addr: "192.0.2.0".parse().expect("parse IPv4"),
            prefix_len: 24,
            max_len: 24,
            asn: 64496,
        }],
        vaps: vec![ParsedAspa {
            customer_asn: 174,
            provider_asns: vec![0],
        }],
    };

    let conversion =
        snapshot_to_payloads_with_options(&snapshot, false).expect("non-strict conversion");

    assert_eq!(conversion.payloads.len(), 1);
    assert!(conversion.invalid_vrps.is_empty());
    assert_eq!(conversion.invalid_vaps.len(), 1);
    assert!(conversion.invalid_vaps[0].contains("provider list must not contain AS0"));
}