extern crate gob;
extern crate partial_io;
extern crate serde;
extern crate serde_bytes;
#[macro_use]
extern crate serde_derive;
#[macro_use]
extern crate quickcheck;

use std::collections::HashMap;
use std::io::Cursor;

use gob::{error::ErrorKind, Deserializer, StreamDeserializer};
use partial_io::{GenWouldBlock, PartialRead, PartialWithErrors};
use serde::Deserialize;
use serde_bytes::{ByteBuf, Bytes};

#[test]
fn bool_true() {
    let deserializer = Deserializer::from_slice(&[3, 2, 0, 1]);
    let decoded = bool::deserialize(deserializer).unwrap();
    assert_eq!(decoded, true);
}

#[test]
fn bool_false() {
    let deserializer = Deserializer::from_slice(&[3, 2, 0, 0]);
    let decoded = bool::deserialize(deserializer).unwrap();
    assert_eq!(decoded, false);
}

#[test]
fn u8_zero() {
    let deserializer = Deserializer::from_slice(&[3, 6, 0, 0]);
    let decoded = u8::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0);
}

#[test]
fn u8_overflow() {
    let deserializer = Deserializer::from_slice(&[5, 6, 0, 254, 4, 210]);
    let result = u8::deserialize(deserializer);
    assert!(result.is_err());
}

#[test]
fn u16_zero() {
    let deserializer = Deserializer::from_slice(&[3, 6, 0, 0]);
    let decoded = u16::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0);
}

#[test]
fn u32_zero() {
    let deserializer = Deserializer::from_slice(&[3, 6, 0, 0]);
    let decoded = u32::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0);
}

#[test]
fn u64_zero() {
    let deserializer = Deserializer::from_slice(&[3, 6, 0, 0]);
    let decoded = u64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0);
}

#[test]
fn u64_small() {
    let deserializer = Deserializer::from_slice(&[3, 6, 0, 42]);
    let decoded = u64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 42);
}

#[test]
fn u64_big() {
    let deserializer = Deserializer::from_slice(&[5, 6, 0, 254, 4, 210]);
    let decoded = u64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 1234);
}

#[test]
fn u64_max() {
    let deserializer =
        Deserializer::from_slice(&[11, 6, 0, 248, 255, 255, 255, 255, 255, 255, 255, 255]);
    let decoded = u64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, ::std::u64::MAX);
}

#[test]
fn i8_zero() {
    let deserializer = Deserializer::from_slice(&[3, 4, 0, 0]);
    let decoded = i8::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0);
}

#[test]
fn i8_overflow() {
    let deserializer = Deserializer::from_slice(&[5, 4, 0, 254, 4, 210]);
    let result = i8::deserialize(deserializer);
    assert!(result.is_err());
}

#[test]
fn i16_zero() {
    let deserializer = Deserializer::from_slice(&[3, 4, 0, 0]);
    let decoded = i16::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0);
}

#[test]
fn i32_zero() {
    let deserializer = Deserializer::from_slice(&[3, 4, 0, 0]);
    let decoded = i32::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0);
}

#[test]
fn i64_zero() {
    let deserializer = Deserializer::from_slice(&[3, 4, 0, 0]);
    let decoded = i64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0);
}

#[test]
fn i64_small_pos() {
    let deserializer = Deserializer::from_slice(&[3, 4, 0, 84]);
    let decoded = i64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 42);
}

#[test]
fn i64_small_neg() {
    let deserializer = Deserializer::from_slice(&[3, 4, 0, 83]);
    let decoded = i64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, -42);
}

#[test]
fn i64_big_pos() {
    let deserializer = Deserializer::from_slice(&[5, 4, 0, 254, 9, 164]);
    let decoded = i64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 1234);
}

#[test]
fn i64_big_neg() {
    let deserializer = Deserializer::from_slice(&[5, 4, 0, 254, 9, 163]);
    let decoded = i64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, -1234);
}

#[test]
fn i64_min() {
    let deserializer =
        Deserializer::from_slice(&[11, 4, 0, 248, 255, 255, 255, 255, 255, 255, 255, 255]);
    let decoded = i64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, ::std::i64::MIN);
}

#[test]
fn i64_max() {
    let deserializer =
        Deserializer::from_slice(&[11, 4, 0, 248, 255, 255, 255, 255, 255, 255, 255, 254]);
    let decoded = i64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, ::std::i64::MAX);
}

#[test]
fn f32_zero() {
    let deserializer = Deserializer::from_slice(&[3, 8, 0, 0]);
    let decoded = f32::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0f32);
}

#[test]
fn f64_zero() {
    let deserializer = Deserializer::from_slice(&[3, 8, 0, 0]);
    let decoded = f64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 0f64);
}

#[test]
fn f64_pos() {
    let deserializer = Deserializer::from_slice(&[5, 8, 0, 254, 69, 64]);
    let decoded = f64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 42f64);
}

#[test]
fn f64_neg() {
    let deserializer = Deserializer::from_slice(&[5, 8, 0, 254, 69, 192]);
    let decoded = f64::deserialize(deserializer).unwrap();
    assert_eq!(decoded, -42f64);
}

#[test]
fn char_ascii() {
    let deserializer = Deserializer::from_slice(&[4, 4, 0, 255, 204]);
    let decoded = char::deserialize(deserializer).unwrap();
    assert_eq!(decoded, 'f');
}

#[test]
fn char_unicode() {
    let deserializer = Deserializer::from_slice(&[6, 4, 0, 253, 1, 21, 60]);
    let decoded = char::deserialize(deserializer).unwrap();
    assert_eq!(decoded, '語');
}

#[test]
fn bytes_empty() {
    let deserializer = Deserializer::from_slice(&[3, 10, 0, 0]);
    let decoded = Bytes::deserialize(deserializer).unwrap();
    assert_eq!(&*decoded, &[]);
}

#[test]
fn bytes_non_empty() {
    let deserializer = Deserializer::from_slice(&[7, 10, 0, 4, 1, 2, 3, 4]);
    let decoded = Bytes::deserialize(deserializer).unwrap();
    assert_eq!(&*decoded, &[1, 2, 3, 4]);
}

#[test]
fn bytebuf_empty() {
    let deserializer = Deserializer::from_slice(&[3, 10, 0, 0]);
    let decoded = ByteBuf::deserialize(deserializer).unwrap();
    assert_eq!(&*decoded, &[]);
}

#[test]
fn bytebuf_non_empty() {
    let deserializer = Deserializer::from_slice(&[7, 10, 0, 4, 1, 2, 3, 4]);
    let decoded = ByteBuf::deserialize(deserializer).unwrap();
    assert_eq!(&*decoded, &[1, 2, 3, 4]);
}

#[test]
fn str_empty() {
    let deserializer = Deserializer::from_slice(&[3, 12, 0, 0]);
    let decoded = <&str>::deserialize(deserializer).unwrap();
    assert_eq!(decoded, "");
}

#[test]
fn str_non_empty() {
    let deserializer = Deserializer::from_slice(&[6, 12, 0, 3, 102, 111, 111]);
    let decoded = <&str>::deserialize(deserializer).unwrap();
    assert_eq!(decoded, "foo");
}

#[test]
fn string_empty() {
    let deserializer = Deserializer::from_slice(&[3, 12, 0, 0]);
    let decoded = String::deserialize(deserializer).unwrap();
    assert_eq!(decoded, "");
}

#[test]
fn string_non_empty() {
    let deserializer = Deserializer::from_slice(&[6, 12, 0, 3, 102, 111, 111]);
    let decoded = String::deserialize(deserializer).unwrap();
    assert_eq!(decoded, "foo");
}

#[test]
fn vec_of_bool_from_empty_slice() {
    let deserializer =
        Deserializer::from_slice(include_bytes!("reference/output/slice_of_bool_empty.gob"));
    let decoded = <Vec<bool>>::deserialize(deserializer).unwrap();
    assert_eq!(decoded, &[]);
}

#[test]
fn vec_of_bool_from_empty_array() {
    let deserializer =
        Deserializer::from_slice(include_bytes!("reference/output/array_of_bool_empty.gob"));
    let decoded = <Vec<bool>>::deserialize(deserializer).unwrap();
    assert_eq!(decoded, &[]);
}

#[test]
fn vec_of_bool_from_non_empty_slice() {
    let deserializer = Deserializer::from_slice(include_bytes!(
        "reference/output/slice_of_bool_non_empty.gob"
    ));
    let decoded = <Vec<bool>>::deserialize(deserializer).unwrap();
    assert_eq!(decoded, &[true, false]);
}

#[test]
fn vec_of_bool_from_non_empty_array() {
    let deserializer = Deserializer::from_slice(include_bytes!(
        "reference/output/array_of_bool_non_empty.gob"
    ));
    let decoded = <Vec<bool>>::deserialize(deserializer).unwrap();
    assert_eq!(decoded, &[true, false]);
}

#[test]
fn vec_of_bool_from_empty_slice_twice() {
    let buffer = include_bytes!("reference/output/slice_of_bool_empty_twice.gob");

    let cursor = Cursor::new(buffer);
    let mut stream = StreamDeserializer::new(cursor);

    let decoded1 = stream.deserialize::<Vec<bool>>().unwrap().unwrap();
    assert_eq!(decoded1, &[]);

    let decoded2 = stream.deserialize::<Vec<bool>>().unwrap().unwrap();
    assert_eq!(decoded2, &[]);
}

#[test]
fn vec_of_bool_from_non_empty_slice_twice() {
    let buffer = include_bytes!("reference/output/slice_of_bool_non_empty_twice.gob");

    let cursor = Cursor::new(buffer);
    let mut stream = StreamDeserializer::new(cursor);

    let decoded1 = stream.deserialize::<Vec<bool>>().unwrap().unwrap();
    assert_eq!(decoded1, &[true, false]);

    let decoded2 = stream.deserialize::<Vec<bool>>().unwrap().unwrap();
    assert_eq!(decoded2, &[false, true]);
}

#[test]
fn map_empty() {
    let deserializer = Deserializer::from_slice(include_bytes!("reference/output/map_empty.gob"));
    let decoded = <HashMap<String, bool>>::deserialize(deserializer).unwrap();
    assert_eq!(decoded.len(), 0);
}

#[test]
fn map_non_empty() {
    let deserializer =
        Deserializer::from_slice(include_bytes!("reference/output/map_non_empty.gob"));
    let decoded = <HashMap<String, bool>>::deserialize(deserializer).unwrap();
    assert_eq!(decoded.len(), 2);
    assert_eq!(decoded["foo"], true);
    assert_eq!(decoded["bar"], false);
}

#[test]
fn complex_64() {
    let deserializer = Deserializer::from_slice(&[6, 14, 0, 254, 240, 63, 64]);
    let decoded = <(f32, f32)>::deserialize(deserializer).unwrap();
    assert_eq!(decoded.0, 1f32);
    assert_eq!(decoded.1, 2f32);
}

#[test]
fn complex_128() {
    let deserializer = Deserializer::from_slice(&[6, 14, 0, 254, 240, 63, 64]);
    let decoded = <(f64, f64)>::deserialize(deserializer).unwrap();
    assert_eq!(decoded.0, 1f64);
    assert_eq!(decoded.1, 2f64);
}

#[test]
fn point_struct() {
    #[derive(Deserialize)]
    struct Point {
        #[serde(rename = "X")]
        x: i64,
        #[serde(rename = "Y")]
        y: i64,
    }

    let deserializer =
        Deserializer::from_slice(include_bytes!("reference/output/point_struct.gob"));

    let decoded = Point::deserialize(deserializer).unwrap();
    assert_eq!(decoded.x, 22);
    assert_eq!(decoded.y, 33);
}

#[test]
fn unit_struct() {
    #[derive(Deserialize)]
    struct EmptyStruct {};

    let deserializer =
        Deserializer::from_slice(include_bytes!("reference/output/empty_struct.gob"));

    EmptyStruct::deserialize(deserializer).unwrap();
}

#[test]
fn enum_with_newtype_variants_and_external_tags() {
    #[derive(Deserialize, Debug, PartialEq, Eq)]
    enum Enum {
        #[serde(rename = "Var1")]
        V1(bool),
        #[serde(rename = "Var2")]
        V2(i64),
        #[serde(rename = "Var3")]
        V3(String),
    }

    let deserializer = Deserializer::from_slice(include_bytes!(
        "reference/output/enum_with_newtype_variants.gob"
    ));

    let decoded = Enum::deserialize(deserializer).unwrap();
    assert_eq!(decoded, Enum::V2(42));
}

#[test]
fn enum_with_struct_variants_and_external_tags() {
    #[derive(Deserialize, Debug, PartialEq, Eq)]
    enum Enum {
        V1 {
            #[serde(rename = "Foo")]
            foo: bool,
        },
        V2 {
            #[serde(rename = "Bar")]
            bar: i64,
            #[serde(rename = "Baz")]
            baz: u64,
        },
        V3 {
            #[serde(rename = "Quux")]
            quux: String,
        },
    }

    let deserializer = Deserializer::from_slice(include_bytes!(
        "reference/output/enum_with_struct_variants.gob"
    ));

    let decoded = Enum::deserialize(deserializer).unwrap();
    assert_eq!(decoded, Enum::V2 { bar: 42, baz: 1234 });
}

#[test]
fn unit_from_any() {
    let buffer = include_bytes!("reference/output/non_empty_values.gob");

    let cursor = Cursor::new(buffer.as_ref());
    let mut stream = StreamDeserializer::new(cursor);

    for _ in 0..7 {
        let () = stream.deserialize::<()>().unwrap().unwrap();
    }
    assert!(stream.deserialize::<()>().unwrap().is_none());
}

quickcheck! {
    fn non_blocking_io(seq: PartialWithErrors<GenWouldBlock>) -> bool {
        macro_rules! block {
            ($e:expr) => {
                loop {
                    #[allow(unreachable_patterns)]
                    match $e {
                        Err(e) => {
                            if e.kind() == ErrorKind::Io(::std::io::ErrorKind::WouldBlock) {
                                continue;
                            } else {
                                break Err(e);
                            }
                        }
                        Ok(x) => break Ok(x),
                    }
                }
            };
        }

        let buffer = include_bytes!("reference/output/non_empty_values.gob");
        let reader = Cursor::new(buffer.as_ref().to_vec());
        let partial_reader = PartialRead::new(reader, seq);
        let mut stream = StreamDeserializer::new(partial_reader);

        assert_eq!(true, block!(stream.deserialize::<bool>()).unwrap().unwrap());
        assert_eq!(42u64, block!(stream.deserialize::<u64>()).unwrap().unwrap());
        assert_eq!(42i64, block!(stream.deserialize::<i64>()).unwrap().unwrap());
        assert_eq!(42f64, block!(stream.deserialize::<f64>()).unwrap().unwrap());
        assert_eq!(
            "foo",
            block!(stream.deserialize::<String>()).unwrap().unwrap()
        );
        assert_eq!(
            ByteBuf::from(vec![0x1, 0x2]),
            block!(stream.deserialize::<ByteBuf>()).unwrap().unwrap()
        );
        assert_eq!(
            vec![true, false],
            block!(stream.deserialize::<Vec<bool>>()).unwrap().unwrap()
        );

        block!(stream.deserialize::<()>()).unwrap().is_none()
    }
}