use std::convert::{TryFrom, Into};

#[cfg(test)]
mod subscribe_package_tests{
    use crate::protocol::SubscribePackage;
    use std::convert::TryFrom;

    #[test]
    fn test(){
        let reference_1 = SubscribePackage{
            is_sub: true,
            key: "SOME KEY".to_string()
        };
        let reference_2 = SubscribePackage{
            is_sub: false,
            key: "".to_string()
        };
        let result: Vec<u8> = reference_1.clone().into();
        match SubscribePackage::try_from(result){
            Ok(result) => {
                assert_eq!(reference_1, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
        let result: Vec<u8> = reference_2.clone().into();
        match SubscribePackage::try_from(result){
            Ok(result) => {
                assert_eq!(reference_2, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
    }
}

#[cfg(test)]
mod registration_package_tests{
    use crate::protocol::RegistrationPackage;
    use std::convert::TryFrom;

    #[test]
    fn test(){
        let reference = RegistrationPackage{ is_router: false };
        let result: Vec<u8> = reference.clone().into();
        match RegistrationPackage::try_from(result){
            Ok(result) => {
                assert_eq!(reference, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
    }
}

#[cfg(test)]
mod message_package_tests{
    use crate::protocol::MessagePackage;
    use std::convert::TryFrom;

    #[test]
    fn test(){
        let reference_1 = MessagePackage{
            key: "SOME KEY".to_string(),
            payload: vec![1, 2, 3, 4, 5],
        };
        let reference_2 = MessagePackage{
            key: "".to_string(),
            payload: vec![],
        };
        let result: Vec<u8> = reference_1.clone().into();
        match MessagePackage::try_from(result){
            Ok(result) => {
                assert_eq!(reference_1, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
        let result: Vec<u8> = reference_2.clone().into();
        match MessagePackage::try_from(result){
            Ok(result) => {
                assert_eq!(reference_2, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
    }
}

#[cfg(test)]
mod package_tests{
    use crate::protocol::{Package, SubscribePackage, RegistrationPackage, MessagePackage};
    use std::convert::TryFrom;

    #[test]
    fn test_sub(){
        let reference_1 = Package::Sub(SubscribePackage{
            is_sub: true,
            key: "SOME KEY".to_string()
        });
        let reference_2 = Package::Sub(SubscribePackage{
            is_sub: false,
            key: "".to_string()
        });
        let result: Vec<u8> = reference_1.clone().into();
        match Package::try_from(result){
            Ok(result) => {
                assert_eq!(reference_1, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
        let result: Vec<u8> = reference_2.clone().into();
        match Package::try_from(result){
            Ok(result) => {
                assert_eq!(reference_2, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
    }
    #[test]
    fn test_reg(){
        let reference = Package::Reg(RegistrationPackage{ is_router: false });
        let result: Vec<u8> = reference.clone().into();
        match Package::try_from(result){
            Ok(result) => {
                assert_eq!(reference, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
    }
    #[test]
    fn test_msg(){
        let reference_1 = Package::Msg(MessagePackage{
            key: "SOME KEY".to_string(),
            payload: vec![1, 2, 3, 4, 5],
        });
        let reference_2 = Package::Msg(MessagePackage{
            key: "".to_string(),
            payload: vec![],
        });
        let result: Vec<u8> = reference_1.clone().into();
        match Package::try_from(result){
            Ok(result) => {
                assert_eq!(reference_1, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
        let result: Vec<u8> = reference_2.clone().into();
        match Package::try_from(result){
            Ok(result) => {
                assert_eq!(reference_2, result)
            }
            Err(_) => {assert!(false, "Unexpected error")}
        }
    }
}

#[derive(Debug, PartialEq, Clone)]
pub struct SubscribePackage {
    pub is_sub: bool,
    pub key: String,
}

#[derive(Debug, PartialEq, Clone)]
pub struct RegistrationPackage{
    pub is_router: bool,
}

#[derive(Debug, PartialEq, Clone)]
pub struct MessagePackage {
    pub key: String,
    pub payload: Vec<u8>,
}

#[derive(Debug, PartialEq, Clone)]
pub enum Package{
    Sub(SubscribePackage),
    Reg(RegistrationPackage),
    Msg(MessagePackage),
}

impl Into<Vec<u8>> for SubscribePackage {
    fn into(self) -> Vec<u8> {
        let header: u8 = match self.is_sub{
            true => {0b01100000}
            false => {0b01000000}
        };
        let mut ret = vec![header];
        ret.append(&mut self.key.into_bytes());
        ret
    }
}

impl TryFrom<Vec<u8>> for SubscribePackage {
    type Error = ();

    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
        let is_sub = (bytes[0] >> 5) & 0b00000001;
        let is_sub = if is_sub == 0 {false} else {true};
        if bytes.len() < 2 {
            return Ok( Self{is_sub, key: "".to_string()} )
        }
        match String::from_utf8(bytes[1..].to_owned()){
            Ok(msg_key) => {
                Ok( Self{is_sub, key: msg_key } )
            }
            Err(_) => { Err(()) }
        }
    }
}

impl Into<Vec<u8>> for RegistrationPackage {
    fn into(self) -> Vec<u8> {
        match self.is_router {
            true => {vec![0b10100000]}
            false => {vec![0b10000000]}
        }
    }
}

impl TryFrom<Vec<u8>> for RegistrationPackage {
    type Error = ();

    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
        let is_router = (bytes[0] >> 5) & 0b00000001;
        let is_router = if is_router == 0 {false} else {true};
        Ok(Self{ is_router })
    }
}

impl Into<Vec<u8>> for MessagePackage {
    fn into(self) -> Vec<u8> {
        let mut ret: Vec<u8> = vec![0b00000000];
        ret.append(&mut self.key.clone().into_bytes());
        ret.push(0); // separator
        ret.append(&mut self.payload.clone());
        ret
    }
}

impl TryFrom<Vec<u8>> for MessagePackage {
    type Error = ();

    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
        if bytes.len() < 2 { return Err(()) }
        let mut str_ends: usize = 1;
        for (nom, char) in bytes[1..].iter().enumerate(){
            str_ends = nom+1;
            if *char == 0{ break }
        }
        match String::from_utf8(bytes[1..str_ends].to_owned()){
            Ok(msg_key) => {
                let payload = bytes[str_ends+1..].to_vec();
                Ok(Self{ key: msg_key, payload})
            }
            Err(_) => { Err(()) }
        }
    }
}

impl Into<Vec<u8>> for Package {
    fn into(self) -> Vec<u8> {
        match self{
            Package::Msg(msg) => {msg.into()}
            Package::Sub(sub) => {sub.into()}
            Package::Reg(node) => {node.into()}
        }
    }
}

impl TryFrom<Vec<u8>> for Package {
    type Error = ();

    fn try_from(bytes: Vec<u8>) -> Result<Self, Self::Error> {
        if bytes.len() < 1 { return Err(()) }
        let type_ = bytes[0] >> 6;
        match type_{
            0 => {
                match MessagePackage::try_from(bytes){
                    Err(_) => { Err(()) }
                    Ok(msg) => { Ok(Self::Msg(msg)) }
                }
            }
            1 => {
                match SubscribePackage::try_from(bytes){
                    Err(_) => { Err(()) }
                    Ok(sub) => { Ok(Self::Sub(sub)) }
                }
            }
            2 => {
                match RegistrationPackage::try_from(bytes){
                    Err(_) => { Err(()) }
                    Ok(node) => { Ok(Self::Reg(node)) }
                }
            }
            _ => { Err(()) }
        }
    }
}