use crate::{
    auth,
    connection::{
        handshake::{self, dirsync, Handshake},
        ID,
    },
    enc::{self, asym::KeyID},
};

#[test]
fn test_handshake_dirsync_req() {
    let rand = enc::Random::new();
    let cipher = enc::sym::Kind::XChaCha20Poly1305;

    let (_, exchange_key) =
        match enc::asym::KeyExchangeKind::X25519DiffieHellman.new_keypair(&rand)
        {
            Ok(pair) => pair,
            Err(_) => {
                assert!(false, "Can't generate random keypair");
                return;
            }
        };

    let data = dirsync::req::State::ClearText(dirsync::req::Data {
        nonce: dirsync::Nonce::new(&rand),
        client_key_id: KeyID(2424),
        id: ID::ID(::core::num::NonZeroU64::new(424242).unwrap()),
        auth: dirsync::req::AuthInfo {
            user: auth::UserID::new(&rand),
            token: auth::Token::new_anonymous(&rand),
            service_id: auth::SERVICEID_AUTH,
            domain: auth::Domain("example.com".to_owned()),
        },
    });

    let h_req = Handshake::new(handshake::Data::DirSync(
        dirsync::DirSync::Req(dirsync::req::Req {
            key_id: KeyID(4224),
            exchange: enc::asym::KeyExchangeKind::X25519DiffieHellman,
            hkdf: enc::hkdf::Kind::Sha3,
            cipher: enc::sym::Kind::XChaCha20Poly1305,
            exchange_key,
            data,
        }),
    ));

    let mut bytes = Vec::<u8>::with_capacity(
        h_req.len(cipher.nonce_len(), cipher.tag_len()),
    );
    bytes.resize(h_req.len(cipher.nonce_len(), cipher.tag_len()), 0);
    h_req.serialize(cipher.nonce_len(), cipher.tag_len(), &mut bytes);

    let mut deserialized = match Handshake::deserialize(&bytes) {
        Ok(deserialized) => deserialized,
        Err(e) => {
            assert!(false, "{}", e.to_string());
            return;
        }
    };
    if let handshake::Data::DirSync(dirsync::DirSync::Req(r_a)) =
        &mut deserialized.data
    {
        let enc_start = r_a.encrypted_offset() + cipher.nonce_len().0;
        if let Err(e) = r_a.data.deserialize_as_cleartext(
            &bytes[enc_start..(bytes.len() - cipher.tag_len().0)],
        ) {
            assert!(false, "DirSync Req Inner serialize: {}", e.to_string());
        }
    };

    assert!(
        deserialized == h_req,
        "DirSync Req (de)serialization not working",
    );
}
#[test]
fn test_handshake_dirsync_reqsp() {
    let rand = enc::Random::new();
    let cipher = enc::sym::Kind::XChaCha20Poly1305;

    let service_key = enc::Secret::new_rand(&rand);

    let data = dirsync::resp::State::ClearText(dirsync::resp::Data {
        client_nonce: dirsync::Nonce::new(&rand),
        id: ID::ID(::core::num::NonZeroU64::new(424242).unwrap()),
        service_connection_id: ID::ID(
            ::core::num::NonZeroU64::new(434343).unwrap(),
        ),
        service_key,
    });

    let h_resp = Handshake::new(handshake::Data::DirSync(
        dirsync::DirSync::Resp(dirsync::resp::Resp {
            client_key_id: KeyID(4444),
            data,
        }),
    ));

    let mut bytes = Vec::<u8>::with_capacity(
        h_resp.len(cipher.nonce_len(), cipher.tag_len()),
    );
    bytes.resize(h_resp.len(cipher.nonce_len(), cipher.tag_len()), 0);
    h_resp.serialize(cipher.nonce_len(), cipher.tag_len(), &mut bytes);

    let mut deserialized = match Handshake::deserialize(&bytes) {
        Ok(deserialized) => deserialized,
        Err(e) => {
            assert!(false, "{}", e.to_string());
            return;
        }
    };
    if let handshake::Data::DirSync(dirsync::DirSync::Resp(r_a)) =
        &mut deserialized.data
    {
        let enc_start = r_a.encrypted_offset() + cipher.nonce_len().0;
        if let Err(e) = r_a.data.deserialize_as_cleartext(
            &bytes[enc_start..(bytes.len() - cipher.tag_len().0)],
        ) {
            assert!(false, "DirSync Resp Inner serialize: {}", e.to_string());
        }
    };

    assert!(
        deserialized == h_resp,
        "DirSync Resp (de)serialization not working",
    );
}