use network::bincode::SizeLimit;
use network::bincode::rustc_serialize::{encode,decode};
use rustc_serialize;


#[derive(RustcEncodable,RustcDecodable,PartialEq,Debug)]
pub enum Message {
    Invalid,
    Login {
        user: String,
        pass: String,
        conf: String
    },
    Logout {
        code: u8
    },
    Update {
        tick: u32
    }
}

pub fn write(msg: &Message) -> Vec<u8> {
    match encode(msg, SizeLimit::Infinite) {
        Result::Ok(val) => val,
        Result::Err(err) => vec![0],
    }
}

pub fn read(buf: &Vec<u8>) -> Message {
    match decode(&buf[..]) {
        Result::Ok(val) => val,
        Result::Err(err) => Message::Invalid,
    }
}

#[cfg(test)]
mod test
{
    use network::protocol::*;
    #[test]
    fn message_serialize(){
    let msg0: Message = Message::Login {
        user: String::from("user"),
        pass: String::from("secret"),
        conf: String::from("looking good")
    };
    let buff = write(&msg0);
    assert!(buff.len() != 0);
    let msg1: Message = read(&buff);
    assert_eq!(msg0, msg1);
    }
}