bipack_ru 0.4.4

use serde::de::{self, DeserializeSeed, IntoDeserializer, MapAccess, SeqAccess, Visitor};
use serde::de::value::U32Deserializer;
use serde::Deserialize;

use crate::bipack_source::{BipackError, BipackSource, SliceSource};
use crate::error::Result;

pub struct Deserializer<T: BipackSource> {
    // This string starts with the input data and characters are truncated off
    // the beginning as data is parsed.
    input: T,
}

pub fn from_bytes<'b, T: Deserialize<'b>>(source: &[u8]) -> Result<T> {
    let mut des = Deserializer { input: SliceSource::from(&source) };
    T::deserialize(&mut des)
}

impl<'de, 'a, T: BipackSource> de::Deserializer<'de> for &'a mut Deserializer<T> {
    type Error = BipackError;

    fn deserialize_any<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(BipackError::NotPossible)
    }

    fn deserialize_bool<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_bool(if self.input.get_u8()? == 0 { false } else { true })
    }

    fn deserialize_i8<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_i8(self.input.get_i8()?)
    }

    fn deserialize_i16<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_i16(self.input.get_signed()? as i16)
    }

    fn deserialize_i32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_i32(self.input.get_signed()? as i32)
    }

    fn deserialize_i64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_i64(self.input.get_signed()?)
    }

    fn deserialize_u8<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_u8(self.input.get_u8()?)
    }

    fn deserialize_u16<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_u16(self.input.get_unsigned()? as u16)
    }

    fn deserialize_u32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_u32(self.input.get_unsigned()? as u32)
    }

    fn deserialize_u64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_u64(self.input.get_unsigned()?)
    }

    fn deserialize_f32<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(BipackError::NotImplemented)
    }

    fn deserialize_f64<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(BipackError::NotImplemented)
    }

    fn deserialize_char<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        let ch = self.input.get_str()?;
        if ch.len() != 1 {
            Err(BipackError::BadFormat(format!("Char length is {}, should be 1 {:?}", ch.len(), ch)))
        } else {
            visitor.visit_char(ch.chars().next().unwrap())
        }
    }

    fn deserialize_str<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_string(self.input.get_str()?)
    }

    fn deserialize_string<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_string(self.input.get_str()?)
    }

    fn deserialize_bytes<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_byte_buf(self.input.get_var_bytes()?)
    }

    fn deserialize_byte_buf<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_byte_buf(self.input.get_var_bytes()?)
    }

    fn deserialize_option<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        let marker = self.input.get_u8()?;
        if marker == 0 {
            visitor.visit_none()
        } else {
            visitor.visit_some(self)
        }
    }

    fn deserialize_unit<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_unit()
    }

    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        self.deserialize_unit(visitor)
    }

    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_newtype_struct(self)
    }

    fn deserialize_seq<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        let size = self.input.get_unsigned()? as usize;
        visitor.visit_seq(SimpleSeq::new(self, size))
    }

    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_seq(SimpleSeq::new(self, len))
    }

    fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_seq(SimpleSeq::new(self, len))
    }

    fn deserialize_map<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        let size = self.input.get_unsigned()?;
        visitor.visit_map(SimpleMap { de: self, size: size as usize })
    }

    fn deserialize_struct<V>(self, name: &'static str, fields: &'static [&'static str], visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        visitor.visit_seq(SimpleSeq::new(self, fields.len()))
    }

    #[inline]
    fn deserialize_enum<V>(
        self,
        _name: &'static str,
        _variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value>
        where
            V: Visitor<'de>,
    {
        visitor.visit_enum(self)
    }

    fn deserialize_identifier<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(BipackError::NotPossible)
    }

    fn deserialize_ignored_any<V>(self, visitor: V) -> std::result::Result<V::Value, Self::Error> where V: Visitor<'de> {
        Err(BipackError::NotPossible)
    }

    fn is_human_readable(&self) -> bool {
        false
    }
}

impl<'de, 'a, T: BipackSource> de::EnumAccess<'de> for &'a mut Deserializer<T> {
    type Error = BipackError;
    type Variant = Self;

    #[inline]
    fn variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<(V::Value, Self)> {
        let varint: u32 = self.input.get_unsigned()? as u32;
        let v = DeserializeSeed::deserialize::<U32Deserializer<BipackError>>(
            seed,
            varint.into_deserializer())?;
        Ok((v, self))
    }
}

impl<'de, 'a, T: BipackSource> de::VariantAccess<'de> for &'a mut Deserializer<T> {
    type Error = BipackError;

    #[inline]
    fn unit_variant(self) -> Result<()> {
        Ok(())
    }

    #[inline]
    fn newtype_variant_seed<V: DeserializeSeed<'de>>(self, seed: V) -> Result<V::Value> {
        DeserializeSeed::deserialize(seed, self)
    }

    #[inline]
    fn tuple_variant<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
        serde::de::Deserializer::deserialize_tuple(self, len, visitor)
    }

    #[inline]
    fn struct_variant<V: Visitor<'de>>(
        self,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value> {
        serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
    }
}


struct SimpleSeq<'a, T: BipackSource> {
    de: &'a mut Deserializer<T>,
    size: usize,
}

impl<'a, T: BipackSource> SimpleSeq<'a, T> {
    fn new(de: &'a mut Deserializer<T>, size: usize) -> Self {
        SimpleSeq {
            de,
            size,
        }
    }
}

// `SeqAccess` is provided to the `Visitor` to give it the ability to iterate
// through elements of the sequence.
impl<'de, 'a, T: BipackSource> SeqAccess<'de> for SimpleSeq<'a, T> {
    type Error = BipackError;

    fn next_element_seed<S>(&mut self, seed: S) -> Result<Option<S::Value>>
        where
            S: DeserializeSeed<'de>,
    {
        if self.size < 1 {
            return Ok(None);
        }
        self.size -= 1;
        seed.deserialize(&mut *self.de).map(Some)
    }
}


struct SimpleMap<'a, T: BipackSource> {
    de: &'a mut Deserializer<T>,
    size: usize,
}

impl<'de, 'a, T: BipackSource> MapAccess<'de> for SimpleMap<'a, T> {
    type Error = BipackError;

    fn next_key_seed<K>(&mut self, seed: K) -> std::result::Result<Option<K::Value>, Self::Error> where K: DeserializeSeed<'de> {
        if self.size < 1 {
            Ok(None)
        } else {
            self.size -= 1;
            seed.deserialize(&mut *self.de).map(Some)
        }
    }

    fn next_value_seed<V>(&mut self, seed: V) -> std::result::Result<V::Value, Self::Error> where V: DeserializeSeed<'de> {
        seed.deserialize(&mut *self.de)
    }
}

#[cfg(test)]
mod tests {
    use std::collections::{HashMap, HashSet};
    use std::fmt::Debug;

    use serde::{Deserialize, Serialize};

    use crate::bipack_source::BipackError;
    use crate::de::from_bytes;
    use crate::error::Result;
    use crate::ser::{to_buffer, to_bytes};
    use crate::tools::{to_dump, ToDump};

    #[test]
    fn test_ints() -> Result<()> {
        // #[derive(Deserialize, PartialEq, Debug)]
        // struct Test {
        //     int: u32,
        //     seq: Vec<String>,
        // }

        let b = vec![7];
        assert_eq!(7u8, from_bytes(&vec![7u8])?);


        // let j = r#"{"int":1,"seq":["a","b"]}"#;
        // let expected = Test {
        //     int: 1,
        //     seq: vec!["a".to_owned(), "b".to_owned()],
        // };
        // assert_eq!(expected, from_str(j).unwrap());
        Ok(())
    }

    #[test]
    fn test_struct() -> Result<()> {
        #[derive(Serialize, Deserialize, PartialEq, Debug)]
        struct Test {
            int: u32,
            seq: Vec<String>,
        }
        let expected = Test {
            int: 1,
            seq: vec!["a".to_owned(), "b".to_owned()],
        };

        let packed = to_bytes(&expected)?;
        println!("::{}", to_dump(&packed));
        let unpacked: Test = from_bytes(&packed)?;
        println!("::{:?}", unpacked);
        assert_eq!(&expected, &unpacked);
        Ok(())

        // let j = r#"{"int":1,"seq":["a","b"]}"#;
        // assert_eq!(expected, from_str(j).unwrap());
    }

    #[test]
    fn test_map() -> Result<()> {
        let mut src = HashMap::new();
        // src.insert("foo".to_string(), 1);
        src.insert("foo".to_string(), 42);
        src.insert("bar".to_string(), 1);
        src.insert("baz".to_string(), 17);
        let packed = to_bytes(&src)?;
        println!("{}", to_dump(&packed));

        let restored: HashMap<String, i32> = from_bytes(&packed)?;
        println!("{:?}", restored);
        assert_eq!(src, restored);

        Ok(())
    }

    #[test]
    fn test_set() -> Result<()> {
        let src = HashSet::from(["foo", "bar", "buz"].map(|i| i.to_string()));
        let packed = to_bytes(&src)?;
        println!("{}", to_dump(&packed));

        let restored: HashSet<String> = from_bytes(&packed)?;
        println!("{:?}", restored);
        assert_eq!(src, restored);

        Ok(())
    }


    fn testeq<T: Serialize + Deserialize<'static> + PartialEq + Debug>(x: &T) {
        {
            let packed = to_bytes(x).unwrap();
            println!("packed {:?}:\n{}", x, to_dump(&packed));
            let z: T = from_bytes(&packed).unwrap();
            assert_eq!(*x, from_bytes(&packed).unwrap());
            if packed.len() > 1 {
                let mut small_buffer = [0u8; 1];
                let result = to_buffer(x, &mut small_buffer);
                assert_eq!(true, result.is_err());
                assert_eq!(BipackError::BufferOverflow, result.err().unwrap());
            }
        }

        let mut buffer = [0u8; 128];
        let packed2 = to_buffer(x, &mut buffer).unwrap();
        assert_eq!(*x, from_bytes(&packed2).unwrap());
    }

    #[test]
    fn test_enum() -> Result<()> {
        #[derive(Serialize, Deserialize, Debug, PartialEq)]
        enum E {
            Unit,
            Unit2,
            Newtype(u32),
            Tuple(u32, u32),
            Struct { a: u32 },
        }

        let packed = to_bytes(&E::Newtype(7))?;
        println!("{}", to_dump(&packed));
        let r: E = from_bytes(&packed)?;
        println!("{:?}", r);

        testeq(&E::Unit);
        testeq(&E::Unit2);
        testeq(&E::Newtype(101));
        testeq(&E::Tuple(17, 42));
        testeq(&E::Struct { a: 19 });

        Ok(())
    }

    #[test]
    fn test_arrays() {
        let x = (1, 2, 3, 4, 5);
        // println!("{:?}",x);
        // println!("{}", to_dump(to_bytes(&x).unwrap().as_slice()));
        assert_eq!(5, to_bytes(&x).unwrap().len());
        testeq(&x);
        let y: [u8; 5] = [1, 2, 3, 4, 5];
        println!("{}", to_dump(to_bytes(&y).unwrap().as_slice()));
        assert_eq!(5, to_bytes(&y).unwrap().len());
        assert_eq!(y, to_bytes(&y).unwrap()[..]);
        testeq(&y);
        let z = vec![1, 2, 3, 4, 5];
        assert_eq!(6, to_bytes(&z).unwrap().len());
        assert_eq!(z, to_bytes(&z).unwrap()[1..]);
    }

    // This is real life sample bug:
    #[derive(Debug,Serialize,Deserialize,Eq, PartialEq)]
    pub enum LogLevel {
        Debug,
        Info,
        Warning,
        Error,
    }

    #[derive(Serialize,Deserialize,Debug,PartialEq)]
    pub struct LogArgs(
        pub LogLevel,
        pub String
    );

    #[test]
    fn test_logargs() {
        let x = LogArgs(LogLevel::Debug,"hello".to_string());
        let packed = to_bytes(&x).unwrap();
        // println!("{}", packed.to_dump());
        let y: LogArgs = from_bytes(&packed).unwrap();
        // println!("{:?}", y);
        assert_eq!(LogLevel::Debug, y.0);
        assert_eq!("hello", y.1);
        assert_eq!(7, packed.len());
    }

    #[test]
    fn test_str() {
        let src = "hello";
        let x = to_bytes(src);
        println!("{}", x.unwrap().to_dump());
    }

}