extern crate serde;
extern crate serde_bytes;
extern crate rmp_serde;
#[macro_use] extern crate serde_utils;

use std::fmt::Debug;
use std::io::Cursor;

fn to_bytes<T: serde::Serialize + Debug>(obj: &T) -> Vec<u8> {
    let mut serialized = Vec::new();
    {
        let mut writer = rmp_serde::Serializer::new(&mut serialized);
        assert!(obj.serialize(&mut writer).is_ok());
    }
    serialized
}

fn from_bytes<'a, T: serde::Deserialize<'a> + Debug>(bytes: &[u8]) -> T {
    let cursor = Cursor::new(bytes);
    let mut reader = rmp_serde::Deserializer::new(cursor);
    T::deserialize(&mut reader).unwrap()
}

#[allow(unknown_lints,needless_pass_by_value)]
fn test_obj<'a, T: serde::Serialize + serde::Deserialize<'a> + PartialEq + Debug>(obj: T) {
    let serialized = to_bytes(&obj);
    let deserialized = from_bytes(&serialized);
    assert_eq!(obj, deserialized);
}

#[derive(Default, Debug, PartialEq)]
struct IntMapTestReduced {
    test: String,
    option: Option<bool>,
}
serde_impl!(IntMapTestReduced(u64) {
    test: String => 0,
    option: Option<bool> => 2
});

#[derive(Default, Debug, PartialEq)]
struct IntMapTest {
    test: String,
    num: u64,
    option: Option<bool>,
}
serde_impl!(IntMapTest(u64) {
    test: String => 0,
    num: u64 => 1,
    option: Option<bool> => 2
});

#[derive(Default, Debug, PartialEq)]
struct CompressedIntMapTest {
    test: String,
    num: u64,
    option: Option<bool>,
}
serde_impl!(CompressedIntMapTest(u64?) {
    test: String => 0,
    num: u64 => 1,
    option: Option<bool> => 2
});

#[test]
fn test_int_map() {
    test_obj(IntMapTest{test: "".to_string(), num: 0, option: None});
    test_obj(IntMapTest{test: "test".to_string(), num: 56, option: Some(true)});
}

#[test]
fn test_int_map_reduced() {
    let bytes = to_bytes(&IntMapTestReduced{test: "test".to_string(), option: Some(true)});
    let obj = from_bytes(&bytes);
    assert_eq!(IntMapTest{test: "test".to_string(), num: 0, option: Some(true)}, obj);
}

#[test]
fn test_int_map_extended() {
    let bytes = to_bytes(&IntMapTest{test: "test".to_string(), num: 56, option: Some(true)});
    let obj = from_bytes(&bytes);
    assert_eq!(IntMapTestReduced{test: "test".to_string(), option: Some(true)}, obj);
}

#[test]
fn test_compressed_int_map() {
    test_obj(CompressedIntMapTest{test: "".to_string(), num: 0, option: None});
    test_obj(CompressedIntMapTest{test: "test".to_string(), num: 56, option: Some(true)});
    assert_eq!(to_bytes(&CompressedIntMapTest::default()).len(), 1);
}

#[derive(Default, Debug, PartialEq)]
struct StrMapTest {
    test: String,
    num: u64,
    option: Option<bool>,
}
serde_impl!(StrMapTest(String) {
    test: String => "test",
    num: u64 => "num",
    option: Option<bool> => "option"
});

#[derive(Default, Debug, PartialEq)]
struct StrMapTestReduced {
    test: String,
    option: Option<bool>,
}
serde_impl!(StrMapTestReduced(String) {
    test: String => "test",
    option: Option<bool> => "option"
});

#[test]
fn test_str_map() {
    test_obj(StrMapTest{test: "".to_string(), num: 0, option: None});
    test_obj(StrMapTest{test: "test".to_string(), num: 56, option: Some(true)});
}

#[test]
fn test_str_map_reduced() {
    let bytes = to_bytes(&StrMapTestReduced{test: "test".to_string(), option: Some(true)});
    let obj = from_bytes(&bytes);
    assert_eq!(StrMapTest{test: "test".to_string(), num: 0, option: Some(true)}, obj);
}

#[test]
fn test_str_map_extended() {
    let bytes = to_bytes(&StrMapTest{test: "test".to_string(), num: 56, option: Some(true)});
    let obj = from_bytes(&bytes);
    assert_eq!(StrMapTestReduced{test: "test".to_string(), option: Some(true)}, obj);
}

#[derive(Default, Debug, PartialEq)]
struct TupleTest {
    test: String,
    num: u64,
    option: Option<bool>,
}
serde_impl!(TupleTest {
    test: String,
    num: u64,
    option: Option<bool>
});

#[derive(Default, Debug, PartialEq)]
struct TupleTestReduced {
    test: String,
    option: Option<bool>,
}
serde_impl!(TupleTestReduced {
    test: String,
    option: Option<bool>
});

#[test]
fn test_tuple() {
    test_obj(TupleTest{test: "".to_string(), num: 0, option: None});
    test_obj(TupleTest{test: "test".to_string(), num: 56, option: Some(true)});
}

#[test]
#[should_panic]
fn test_tuple_reduced() {
    let bytes = to_bytes(&TupleTestReduced{test: "test".to_string(), option: Some(true)});
    let obj = from_bytes(&bytes);
    assert_eq!(TupleTest{test: "test".to_string(), num: 0, option: Some(true)}, obj);
}

#[test]
#[should_panic]
fn test_tuple_extended() {
    let bytes = to_bytes(&TupleTest{test: "test".to_string(), num: 56, option: Some(true)});
    let obj = from_bytes(&bytes);
    assert_eq!(TupleTestReduced{test: "test".to_string(), option: Some(true)}, obj);
}