use std::net::IpAddr;
use std::str::FromStr;

use rpki::rtr::loader::{
    parse_aspa_line, parse_router_key_line, parse_vrp_line, ParsedAspa, ParsedVrp,
};

#[test]
fn parse_ipv4_vrp_line() {
    let got = parse_vrp_line("10.0.0.0/24,24,65001").unwrap();
    assert_eq!(
        got,
        ParsedVrp {
            prefix_addr: IpAddr::from_str("10.0.0.0").unwrap(),
            prefix_len: 24,
            max_len: 24,
            asn: 65001,
        }
    );
}

#[test]
fn parse_ipv6_vrp_line() {
    let got = parse_vrp_line("2001:db8::/32,48,65003").unwrap();
    assert_eq!(
        got,
        ParsedVrp {
            prefix_addr: IpAddr::from_str("2001:db8::").unwrap(),
            prefix_len: 32,
            max_len: 48,
            asn: 65003,
        }
    );
}

#[test]
fn parse_rejects_invalid_max_len() {
    let err = parse_vrp_line("10.0.0.0/24,16,65001").unwrap_err();
    assert!(err.to_string().contains("max_len"));
}

#[test]
fn parse_rejects_invalid_ip() {
    let err = parse_vrp_line("10.0.0.999/24,24,65001").unwrap_err();
    assert!(err.to_string().contains("invalid IP"));
}

#[test]
fn parse_rejects_invalid_format() {
    let err = parse_vrp_line("10.0.0.0/24,24").unwrap_err();
    assert!(err.to_string().contains("expected format"));
}

#[test]
fn parse_aspa_line_ok() {
    let got = parse_aspa_line("64496,64497 64498").unwrap();
    assert_eq!(
        got,
        ParsedAspa {
            customer_asn: 64496,
            provider_asns: vec![64497, 64498],
        }
    );
}

#[test]
fn parse_aspa_rejects_empty_provider_list() {
    let err = parse_aspa_line("64496,").unwrap_err();
    assert!(err.to_string().contains("provider list"));
}

#[test]
fn parse_aspa_rejects_as0() {
    let err = parse_aspa_line("0,64497").unwrap_err();
    assert!(err.to_string().contains("AS0"));

    let err = parse_aspa_line("64496,0").unwrap_err();
    assert!(err.to_string().contains("AS0"));
}

#[test]
fn parse_router_key_line_ok() {
    let got = parse_router_key_line(
        "00112233445566778899aabbccddeeff00112233,64496,3013300d06092a864886f70d010101050003020000",
    )
    .unwrap();
    assert_eq!(got.asn, 64496);
    assert_eq!(
        got.ski,
        [
            0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa, 0xbb, 0xcc,
            0xdd, 0xee, 0xff, 0x00, 0x11, 0x22, 0x33,
        ]
    );
    assert_eq!(
        got.spki,
        vec![
            0x30, 0x13, 0x30, 0x0d, 0x06, 0x09, 0x2a, 0x86, 0x48, 0x86, 0xf7, 0x0d, 0x01,
            0x01, 0x01, 0x05, 0x00, 0x03, 0x02, 0x00, 0x00,
        ]
    );
}

#[test]
fn parse_router_key_rejects_invalid_ski_length() {
    let err = parse_router_key_line("0011,64496,deadbeef").unwrap_err();
    assert!(err.to_string().contains("SKI"));
}

#[test]
fn parse_router_key_rejects_empty_spki() {
    let err =
        parse_router_key_line("00112233445566778899aabbccddeeff00112233,64496,").unwrap_err();
    assert!(err.to_string().contains("SPKI"));
}

#[test]
fn parse_router_key_rejects_invalid_spki_der() {
    let err =
        parse_router_key_line("00112233445566778899aabbccddeeff00112233,64496,deadbeef")
            .unwrap_err();
    assert!(err.to_string().contains("valid DER"));
}