use bp7::flags::*;
use bp7::*;
use std::convert::TryFrom;
use std::convert::TryInto;

#[test]
fn canonical_data_tests() {
    let data = CanonicalData::Data(b"bla".to_vec());
    let encoded_data = serde_cbor::to_vec(&data).expect("encoding error");
    let decoded_data: CanonicalData =
        serde_cbor::from_slice(&encoded_data).expect("decoding error");
    assert_eq!(data, decoded_data);

    let bundleage = dbg!(CanonicalData::BundleAge(23));
    let encoded_bundleage = serde_cbor::to_vec(&bundleage).expect("encoding error");
    let decoded_bundleage: CanonicalData =
        serde_cbor::from_slice(&encoded_bundleage).expect("decoding error");
    assert_eq!(bundleage, decoded_bundleage);

    let hopcount = CanonicalData::HopCount(23, 42);
    let encoded_hopcount = serde_cbor::to_vec(&hopcount).expect("encoding error");
    let decoded_hopcount: CanonicalData =
        serde_cbor::from_slice(&encoded_hopcount).expect("decoding error");
    assert_eq!(hopcount, decoded_hopcount);

    let previous = CanonicalData::PreviousNode("dtn://node1".try_into().unwrap());
    let encoded_previous = serde_cbor::to_vec(&previous).expect("encoding error");
    let decoded_previous: CanonicalData =
        serde_cbor::from_slice(&encoded_previous).expect("decoding error");
    assert_eq!(previous, decoded_previous);
}

fn encode_decode_test_canonical(data: CanonicalBlock) {
    let encoded_data = serde_cbor::to_vec(&data).expect("encoding error");
    let decoded_data: CanonicalBlock =
        serde_cbor::from_slice(&encoded_data).expect("decoding error");
    assert_eq!(data, decoded_data);

    println!("{:?}", decoded_data.data());
    assert_eq!(decoded_data.data(), data.data());
    if *decoded_data.data() == CanonicalData::DecodingError {
        panic!("Wrong Payload");
    }
}

#[test]
fn canonical_block_tests() {
    let data = new_payload_block(BlockControlFlags::empty(), b"ABCDEFG".to_vec());
    encode_decode_test_canonical(data);

    let data = new_hop_count_block(1, BlockControlFlags::empty(), 32);
    encode_decode_test_canonical(data);

    let data = new_bundle_age_block(1, BlockControlFlags::empty(), 0);
    encode_decode_test_canonical(data);

    let data = new_previous_node_block(
        1,
        BlockControlFlags::empty(),
        "dtn://node2".try_into().unwrap(),
    );
    encode_decode_test_canonical(data);
}

#[test]
fn hopcount_tests() {
    let mut block = new_hop_count_block(1, BlockControlFlags::empty(), 1);

    assert_eq!(block.block_type, bp7::HOP_COUNT_BLOCK);
    assert!(!block.hop_count_exceeded());

    if let CanonicalData::HopCount(hc_limit, hc_count) = block.data() {
        assert!(*hc_limit == 1);
        assert!(*hc_count == 0);
    } else {
        panic!("Not a hop count block!");
    }

    assert!(block.hop_count_increase());
    if let Some((hc_limit, hc_count)) = block.hop_count_get() {
        assert!(hc_limit == 1);
        assert!(hc_count == 1);
    } else {
        panic!("Not a hop count block!");
    }

    assert!(block.hop_count_increase());
    assert!(block.hop_count_exceeded());

    let mut wrong_block = new_bundle_age_block(1, BlockControlFlags::empty(), 0);
    assert!(!wrong_block.hop_count_increase());
    assert!(!wrong_block.hop_count_exceeded());
    assert_eq!(wrong_block.hop_count_get(), None);
}

#[test]
fn previousnode_tests() {
    let mut block = new_previous_node_block(
        1,
        BlockControlFlags::empty(),
        "dtn://node1".try_into().unwrap(),
    );

    assert_eq!(block.block_type, bp7::PREVIOUS_NODE_BLOCK);
    if let Some(eid) = block.previous_node_get() {
        assert_eq!(*eid, EndpointID::try_from("dtn://node1").unwrap());
    } else {
        panic!("Not a previous node block!");
    }

    assert!(block.previous_node_update("dtn://node2".try_into().unwrap()));

    if let Some(eid) = block.previous_node_get() {
        assert_eq!(*eid, EndpointID::try_from("dtn://node2").unwrap());
    } else {
        panic!("Not a previous node block!");
    }

    let mut wrong_block = new_bundle_age_block(1, BlockControlFlags::empty(), 0);
    assert_eq!(wrong_block.previous_node_get(), None);
    assert!(!wrong_block.previous_node_update("dtn://node2".try_into().unwrap()));
}

#[test]
fn bundleage_tests() {
    let mut block = new_bundle_age_block(1, BlockControlFlags::empty(), 0);

    assert_eq!(block.block_type, bp7::BUNDLE_AGE_BLOCK);
    if let Some(age) = block.bundle_age_get() {
        assert_eq!(age, 0);
    } else {
        panic!("Not a bundle age block!");
    }

    assert!(block.bundle_age_update(200));

    if let Some(age) = block.bundle_age_get() {
        assert_eq!(age, 200);
    } else {
        panic!("Not a bundle age block!");
    }

    let mut wrong_block = new_hop_count_block(1, BlockControlFlags::empty(), 1);
    assert_eq!(wrong_block.bundle_age_get(), None);
    assert!(!wrong_block.bundle_age_update(2342));
}