use rpki::storage::{FetchCachePpPack, PackFile, PackTime};

fn sample_pack() -> FetchCachePpPack {
    let this_update =
        PackTime::from_utc_offset_datetime(time::OffsetDateTime::from_unix_timestamp(0).unwrap());
    let next_update = PackTime::from_utc_offset_datetime(
        time::OffsetDateTime::from_unix_timestamp(3600).unwrap(),
    );
    let verified_at =
        PackTime::from_utc_offset_datetime(time::OffsetDateTime::from_unix_timestamp(10).unwrap());

    let file1 = PackFile::from_bytes_compute_sha256(
        "rsync://example.net/repo/CA/1.crl",
        b"crl-bytes".to_vec(),
    );
    let file2 = PackFile::from_bytes_compute_sha256(
        "rsync://example.net/repo/CA/2.cer",
        b"cer-bytes".to_vec(),
    );

    FetchCachePpPack {
        format_version: FetchCachePpPack::FORMAT_VERSION_V1,
        manifest_rsync_uri: "rsync://example.net/repo/CA/manifest.mft".to_string(),
        publication_point_rsync_uri: "rsync://example.net/repo/CA/".to_string(),
        manifest_number_be: vec![1],
        this_update,
        next_update,
        verified_at,
        manifest_bytes: b"manifest-bytes".to_vec(),
        files: vec![file1, file2],
    }
}

#[test]
fn pack_encode_decode_roundtrip() {
    let pack = sample_pack();
    let bytes = pack.encode().expect("encode");
    let decoded = FetchCachePpPack::decode(&bytes).expect("decode");
    assert_eq!(decoded, pack);
}

#[test]
fn pack_rejects_missing_manifest() {
    let mut pack = sample_pack();
    pack.manifest_bytes.clear();
    let bytes = pack.encode().expect("encode");
    assert!(FetchCachePpPack::decode(&bytes).is_err());
}

#[test]
fn pack_rejects_duplicate_rsync_uri_entries() {
    let mut pack = sample_pack();
    let dup =
        PackFile::from_bytes_compute_sha256("rsync://example.net/repo/CA/1.crl", b"other".to_vec());
    pack.files.push(dup);
    let bytes = pack.encode().expect("encode");
    assert!(FetchCachePpPack::decode(&bytes).is_err());
}

#[test]
fn pack_includes_this_update_next_update() {
    let pack = sample_pack();
    let bytes = pack.encode().expect("encode");
    let decoded = FetchCachePpPack::decode(&bytes).expect("decode");

    let this_update = decoded.this_update.parse().expect("parse this_update");
    let next_update = decoded.next_update.parse().expect("parse next_update");
    assert!(next_update > this_update);
}