use crate::peer;

use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
pub struct RegisterSuper<'a> {
    // pass, 用于给registersuper一个初步的雁阵，固定8位
    pub pass: &'a str,
    // 自身的sock信息
    pub sock: Option<peer::SdlanSock>,

    // 自身的ip信息
    pub dev_addr: peer::IpSubnet,

    // 自身的公钥
    pub pub_key: &'a str,

    // user's token, can be used to specify a user
    pub token: &'a str,
}

#[cfg(test)]
mod test {
    use crate::config;
    use crate::packet::decode_packet;
    use crate::packet::encode_packet;
    use crate::packet::PacketType;

    use self::peer::SdlanSock;
    use crate::packet::Common;
    use crate::utils::Result;
    use std::sync::atomic;
    use std::sync::atomic::Ordering::Relaxed;

    use super::*;

    fn do_encode() -> Result<(Vec<u8>, Common<'static>, RegisterSuper<'static>)> {
        let cmn1 = Common {
            version: 1,
            id: "asxalex",
            ttl: 128,
            pc: PacketType::PKTRegisterSuper,
            flags: config::SDLAN_FLAGS_FROM_SN,
        };
        let pkt1 = RegisterSuper {
            pass: "encrypt!",
            sock: Some(SdlanSock {
                family: 0,
                port: 1,
                has_v6: true,
                v6_port: 2345,
                v4: [0; 4],
                v6: [1; 16],
            }),
            dev_addr: peer::IpSubnet {
                net_addr: atomic::AtomicU32::new(192),
                net_bit_len: atomic::AtomicU8::new(24),
            },
            pub_key: "public key",
            token: "user's token",
        };
        let res = encode_packet(&cmn1, &pkt1).unwrap();
        Ok((res, cmn1, pkt1))
    }

    fn do_decode<'a, T: serde::Deserialize<'a>>(value: &'a [u8]) -> Result<(Common, T)> {
        decode_packet(value)
    }

    fn compare_two(cmn1: Common, cmn2: Common, pkt1: RegisterSuper, pkt2: RegisterSuper) {
        assert_eq!(cmn1.version, cmn2.version);
        assert_eq!(cmn1.id, cmn2.id);
        assert_eq!(cmn1.ttl, cmn2.ttl);
        assert_eq!(cmn1.pc, cmn2.pc);
        assert_eq!(cmn1.flags, cmn2.flags);

        assert_eq!(pkt1.pass, pkt2.pass);
        assert_eq!(pkt1.sock, pkt2.sock);
        assert_eq!(
            pkt1.dev_addr.net_addr.load(Relaxed),
            pkt2.dev_addr.net_addr.load(Relaxed)
        );
        assert_eq!(
            pkt1.dev_addr.net_bit_len.load(Relaxed),
            pkt2.dev_addr.net_bit_len.load(Relaxed)
        );
        assert_eq!(pkt1.pub_key, pkt2.pub_key);
        assert_eq!(pkt1.token, pkt2.token);
    }

    #[test]
    fn test_register_super_encode_decode() {
        let (value, cmn1, pkt1) = do_encode().unwrap();
        let (cmn2, pkt2) = do_decode::<RegisterSuper>(&value).unwrap();
        compare_two(cmn1, cmn2, pkt1, pkt2);
    }

    #[test]
    #[should_panic]
    fn test_register_super_encode_decode_panic() {
        let (mut value, cmn1, pkt1) = do_encode().unwrap();
        value.pop();
        let (cmn2, pkt2) = do_decode::<RegisterSuper>(&value).unwrap();
        compare_two(cmn1, cmn2, pkt1, pkt2);
    }

    #[test]
    fn test_register_super_encode_decode_nopanic() {
        let (mut value, cmn1, pkt1) = do_encode().unwrap();
        value.extend_from_slice(&[1; 10]);
        let (cmn2, pkt2) = do_decode::<RegisterSuper>(&value).unwrap();
        compare_two(cmn1, cmn2, pkt1, pkt2);
    }
}