// SPDX-License-Identifier: AGPL-3.0-or-later
use crate::{
    error::{Error, Result},
    reader::{ReadAdapter, Reader, SliceAdapter},
};
use serde::de::{self, Deserialize, DeserializeOwned, DeserializeSeed, IntoDeserializer, Visitor};
use std::convert::TryFrom;
use std::io::Read;
use std::str;

pub fn from_vec<'de, T: Deserialize<'de>>(vec: &'de Vec<u8>) -> Result<T> {
    from_slice(vec.as_slice())
}

pub fn read_from<T: DeserializeOwned, R: Read>(read: &mut R) -> Result<T> {
    let mut de = Deserializer::new(ReadAdapter::new(read));
    Deserialize::deserialize(&mut de)
}

pub fn from_slice<'de, T: Deserialize<'de>>(slice: &'de [u8]) -> Result<T> {
    let mut de = Deserializer::new(SliceAdapter::new(slice));
    Deserialize::deserialize(&mut de)
}

fn try_from<TSource, TDest: TryFrom<TSource>>(value: TSource) -> Result<TDest> {
    let cast = TDest::try_from(value).map_err(|_| Error::TypeConversion)?;
    Ok(cast)
}

/// Returns the number of bytes needed to store the unicode character in UTF-8 whose
/// encoding begins with the given byte. If the given byte is not valid as the first byte
/// for any character, then a failed result with Error::InvalidUtf8Char is returned.
fn num_bytes_for_char(first_byte: u8) -> Result<usize> {
    if first_byte & 128u8 == 0 {
        return Ok(1);
    }
    for bit in 2..5 {
        let mask = 128u8 >> bit;
        if mask & first_byte == 0 {
            return Ok(bit);
        }
    }
    Err(Error::InvalidUtf8)
}

/// Returns the unicode code point of the character that is encoded in UTF-8 in the given buffer
/// as a u32. If the given buffer is not of a valid length then a failed result is returned.
/// No other verification is performed.
fn u32_from_utf8(buf: &[u8]) -> Result<u32> {
    const MASK: u8 = 0b0011_1111;

    fn mask(byte: u8, mask: u8) -> u32 {
        (byte & mask) as u32
    }

    fn two_bytes(buf: &[u8]) -> u32 {
        mask(buf[0], 0b0001_1111) << 6 | mask(buf[1], MASK)
    }

    fn three_bytes(buf: &[u8]) -> u32 {
        mask(buf[0], 0b0000_1111) << 12 | mask(buf[1], MASK) << 6 | mask(buf[2], MASK)
    }

    fn four_bytes(buf: &[u8]) -> u32 {
        mask(buf[0], 0b0000_0111) << 18
            | mask(buf[1], MASK) << 12
            | mask(buf[2], MASK) << 6
            | mask(buf[3], MASK)
    }

    let code_point = match buf.len() {
        1 => Some(buf[0] as u32),
        2 => Some(two_bytes(buf)),
        3 => Some(three_bytes(buf)),
        4 => Some(four_bytes(buf)),
        _ => None,
    };
    code_point.ok_or(Error::InvalidUtf8)
}

fn char_from_utf8(buf: &[u8]) -> Result<char> {
    let result = u32_from_utf8(buf);
    let option = char::from_u32(result?);
    option.ok_or(Error::InvalidUtf8)
}

pub struct Deserializer<T> {
    input: T,
}

impl<'de, T: Reader<'de>> Deserializer<T> {
    pub fn new(input: T) -> Self {
        Self { input }
    }

    fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
        self.input.read_exact(buf)
    }

    fn borrow_bytes(&mut self, len: usize) -> Result<&'de [u8]> {
        self.input.borrow_bytes(len)
    }

    fn read_array<const N: usize>(&mut self) -> Result<[u8; N]> {
        let mut array = [0u8; N];
        self.read_exact(array.as_mut_slice())?;
        Ok(array)
    }

    fn read_u8(&mut self) -> Result<u8> {
        let buf = self.read_array::<1>()?;
        Ok(buf[0])
    }

    fn read_u16(&mut self) -> Result<u16> {
        let buf = self.read_array()?;
        Ok(u16::from_le_bytes(buf))
    }

    fn read_u32(&mut self) -> Result<u32> {
        let buf = self.read_array()?;
        Ok(u32::from_le_bytes(buf))
    }

    fn read_u64(&mut self) -> Result<u64> {
        let buf = self.read_array()?;
        Ok(u64::from_le_bytes(buf))
    }

    fn read_u128(&mut self) -> Result<u128> {
        let buf = self.read_array()?;
        Ok(u128::from_le_bytes(buf))
    }

    fn read_i8(&mut self) -> Result<i8> {
        let value = self.read_u8()?;
        Ok(value as i8)
    }

    fn read_i16(&mut self) -> Result<i16> {
        let value = self.read_u16()?;
        Ok(value as i16)
    }

    fn read_i32(&mut self) -> Result<i32> {
        let value = self.read_u32()?;
        Ok(value as i32)
    }

    fn read_i64(&mut self) -> Result<i64> {
        let value = self.read_u64()?;
        Ok(value as i64)
    }

    fn read_i128(&mut self) -> Result<i128> {
        let value = self.read_u128()?;
        Ok(value as i128)
    }

    fn read_bool(&mut self) -> Result<bool> {
        let byte = self.read_u8()?;
        Ok(byte > 0)
    }

    fn read_vec(&mut self) -> Result<Vec<u8>> {
        let len = try_from(self.read_u32()?)?;
        let mut vec = vec![0; len];
        self.read_exact(vec.as_mut_slice())?;
        Ok(vec)
    }

    fn read_bytes(&mut self) -> Result<&'de [u8]> {
        let len = try_from(self.read_u32()?)?;
        self.borrow_bytes(len)
    }

    fn read_string(&mut self) -> Result<String> {
        let vec = self.read_vec()?;
        let value = String::from_utf8(vec).map_err(|_| Error::TypeConversion)?;
        Ok(value)
    }

    fn read_str(&mut self) -> Result<&'de str> {
        let bytes = self.read_bytes()?;
        std::str::from_utf8(bytes).map_err(|_| Error::InvalidUtf8)
    }
}

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

    fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
        Err(Error::NotSupported("deserialize_any is not supported"))
    }

    fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_bool()?;
        visitor.visit_bool(value)
    }

    fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_i8()?;
        visitor.visit_i8(value)
    }

    fn deserialize_i16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_i16()?;
        visitor.visit_i16(value)
    }

    fn deserialize_i32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_i32()?;
        visitor.visit_i32(value)
    }

    fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_i64()?;
        visitor.visit_i64(value)
    }

    fn deserialize_i128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_i128()?;
        visitor.visit_i128(value)
    }

    fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_u8()?;
        visitor.visit_u8(value)
    }

    fn deserialize_u16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_u16()?;
        visitor.visit_u16(value)
    }

    fn deserialize_u32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_u32()?;
        visitor.visit_u32(value)
    }

    fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_u64()?;
        visitor.visit_u64(value)
    }

    fn deserialize_u128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_u128()?;
        visitor.visit_u128(value)
    }

    fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let mut buf = [0u8; 4];
        self.read_exact(&mut buf)?;
        let value = f32::from_le_bytes(buf);
        visitor.visit_f32(value)
    }

    fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let mut buf = [0u8; 8];
        self.read_exact(&mut buf)?;
        let value = f64::from_le_bytes(buf);
        visitor.visit_f64(value)
    }

    fn deserialize_char<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let byte = self.read_u8()?;
        let char_len = num_bytes_for_char(byte)?;
        let mut buf = [0u8; 4];
        buf[0] = byte;
        self.read_exact(&mut buf[1..char_len])?;
        let result = char_from_utf8(&buf[..char_len]);
        visitor.visit_char(result?)
    }

    fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        if T::can_borrow() {
            let value = self.read_str()?;
            visitor.visit_borrowed_str(value)
        } else {
            self.deserialize_str(visitor)
        }
    }

    fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_string()?;
        visitor.visit_string(value)
    }

    fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        if T::can_borrow() {
            let value = self.read_bytes()?;
            visitor.visit_borrowed_bytes(value)
        } else {
            self.deserialize_byte_buf(visitor)
        }
    }

    fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let value = self.read_vec()?;
        visitor.visit_byte_buf(value)
    }

    fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let some = self.read_bool()?;
        if some {
            visitor.visit_some(self)
        } else {
            visitor.visit_none()
        }
    }

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

    fn deserialize_unit_struct<V: Visitor<'de>>(
        self,
        _name: &'static str,
        visitor: V,
    ) -> Result<V::Value> {
        visitor.visit_unit()
    }

    fn deserialize_newtype_struct<V: Visitor<'de>>(
        self,
        _name: &'static str,
        visitor: V,
    ) -> Result<V::Value> {
        visitor.visit_newtype_struct(self)
    }

    fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let len = self.read_u32()?;
        visitor.visit_seq(SeqAccess {
            elements_left: len,
            deserializer: self,
        })
    }

    fn deserialize_tuple<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
        visitor.visit_seq(SeqAccess {
            elements_left: try_from(len)?,
            deserializer: self,
        })
    }

    fn deserialize_tuple_struct<V: Visitor<'de>>(
        self,
        _name: &'static str,
        len: usize,
        visitor: V,
    ) -> Result<V::Value> {
        self.deserialize_tuple(len, visitor)
    }

    fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
        let len = self.read_u32()?;
        visitor.visit_map(SeqAccess {
            elements_left: len,
            deserializer: self,
        })
    }

    fn deserialize_struct<V: Visitor<'de>>(
        self,
        _name: &'static str,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value> {
        self.deserialize_tuple(fields.len(), visitor)
    }

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

    fn deserialize_identifier<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
        Err(Error::NotSupported("Deserializer::deserialize_identifier"))
    }

    fn deserialize_ignored_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
        Err(Error::NotSupported("Deserializer::deserialize_ignored_any"))
    }

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

struct SeqAccess<'a, T> {
    elements_left: u32,
    deserializer: &'a mut Deserializer<T>,
}

impl<'a, 'de, T: Reader<'de>> de::SeqAccess<'de> for SeqAccess<'a, T> {
    type Error = Error;

    fn next_element_seed<S: DeserializeSeed<'de>>(&mut self, seed: S) -> Result<Option<S::Value>> {
        if 0 == self.elements_left {
            return Ok(None);
        }

        self.elements_left -= 1;
        seed.deserialize(&mut *self.deserializer).map(Some)
    }
}

impl<'a, 'de, T: Reader<'de>> de::MapAccess<'de> for SeqAccess<'a, T> {
    type Error = Error;

    fn next_key_seed<S: DeserializeSeed<'de>>(&mut self, seed: S) -> Result<Option<S::Value>> {
        if 0 == self.elements_left {
            return Ok(None);
        }

        self.elements_left -= 1;
        seed.deserialize(&mut *self.deserializer).map(Some)
    }

    fn next_value_seed<U: DeserializeSeed<'de>>(&mut self, seed: U) -> Result<U::Value> {
        seed.deserialize(&mut *self.deserializer)
    }
}

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

    fn unit_variant(self) -> Result<()> {
        Ok(())
    }

    fn newtype_variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<S::Value> {
        seed.deserialize(self)
    }

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

    fn struct_variant<V: Visitor<'de>>(
        self,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value> {
        de::Deserializer::deserialize_struct(self, "", fields, visitor)
    }
}

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

    fn variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<(S::Value, Self::Variant)> {
        let int = self.read_u16()?;
        let index: u32 = try_from(int)?;
        let value = seed.deserialize(index.into_deserializer())?;
        Ok((value, self))
    }
}

#[cfg(test)]
mod test {
    use crate::{from_slice, to_vec};

    use super::{from_vec, num_bytes_for_char, Result};
    use serde::Deserialize;
    use std::collections::HashMap;

    #[test]
    fn test_num_bytes_for_char() -> Result<()> {
        fn test_case(c: char) -> Result<()> {
            let len = c.len_utf8();
            let mut buf: Vec<u8> = vec![0; len];
            c.encode_utf8(buf.as_mut_slice());
            let result = num_bytes_for_char(buf[0]);
            assert_eq!(len, result?);
            Ok(())
        }

        test_case('$')?;
        test_case('£')?;
        test_case('€')?;
        test_case('😑')?;
        Ok(())
    }

    #[test]
    fn deserialize_false() -> Result<()> {
        let vec: Vec<u8> = vec![0x00];
        let result = from_vec(&vec);
        assert_eq!(false, result?);
        Ok(())
    }

    #[test]
    fn deserialize_true() -> Result<()> {
        let vec: Vec<u8> = vec![0x01];
        let result = from_vec(&vec);
        assert_eq!(true, result?);
        Ok(())
    }

    #[test]
    fn deserialize_i8() -> Result<()> {
        let vec: Vec<u8> = vec![0xFE];
        let result = from_vec(&vec);
        assert_eq!(-2i8, result?);
        Ok(())
    }

    #[test]
    fn deserialize_i16() -> Result<()> {
        let vec: Vec<u8> = vec![0xFD, 0xFF];
        let result = from_vec(&vec);
        assert_eq!(-3i16, result?);
        Ok(())
    }

    #[test]
    fn deserialize_i32() -> Result<()> {
        let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF];
        let result = from_vec(&vec);
        assert_eq!(-2i32, result?);
        Ok(())
    }

    #[test]
    fn deserialize_i64() -> Result<()> {
        let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
        let result = from_vec(&vec);
        assert_eq!(-2i64, result?);
        Ok(())
    }

    #[test]
    fn deserialize_i128() -> Result<()> {
        let vec: Vec<u8> = vec![
            0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
            0xFF, 0xFF,
        ];
        let result = from_vec(&vec);
        assert_eq!(-2i128, result?);
        Ok(())
    }

    #[test]
    fn deserialize_u8() -> Result<()> {
        let vec: Vec<u8> = vec![0xFF];
        let result = from_vec(&vec);
        assert_eq!(255u8, result?);
        Ok(())
    }

    #[test]
    fn deserialize_u16() -> Result<()> {
        let vec: Vec<u8> = vec![0xFE, 0xFF];
        let result = from_vec(&vec);
        assert_eq!(0xFFFEu16, result?);
        Ok(())
    }

    #[test]
    fn deserialize_u32() -> Result<()> {
        let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF];
        let result = from_vec(&vec);
        assert_eq!(0xFFFFFFFEu32, result?);
        Ok(())
    }

    #[test]
    fn deserialize_u64() -> Result<()> {
        let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
        let result = from_vec(&vec);
        assert_eq!(0xFFFFFFFFFFFFFFFEu64, result?);
        Ok(())
    }

    #[test]
    fn deserialize_u128() -> Result<()> {
        let vec: Vec<u8> = vec![
            0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
            0xFF, 0xFF,
        ];
        let result = from_vec(&vec);
        assert_eq!(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEu128, result?);
        Ok(())
    }

    #[test]
    fn deserialize_f32() -> Result<()> {
        let vec: Vec<u8> = vec![0x00, 0x00, 0x20, 0x3E];
        let result = from_vec(&vec);
        assert_eq!(0.15625f32, result?);
        Ok(())
    }

    #[test]
    fn deserialize_f64() -> Result<()> {
        let vec: Vec<u8> = vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F];
        let result = from_vec(&vec);
        assert_eq!(1f64, result?);
        Ok(())
    }

    #[test]
    fn deserialize_char() -> Result<()> {
        fn test_case(c: char, vec: Vec<u8>) -> Result<()> {
            let result = from_vec(&vec);
            assert_eq!(c, result?);
            Ok(())
        }

        test_case('*', vec![0x2A])?;
        test_case('£', vec![0xC2, 0xA3])?;
        test_case('€', vec![0xE2, 0x82, 0xAC])?;
        test_case('😎', vec![0xF0, 0x9F, 0x98, 0x8E])?;
        Ok(())
    }

    /// Returns the bytes that would be returned if the given data were serialized.
    macro_rules! input {
        ($expected:expr) => {{
            const LEN: [u8; 4] = ($expected.len() as u32).to_le_bytes();
            const INPUT_LEN: usize = LEN.len() + EXPECTED.len();
            let mut input = [0u8; INPUT_LEN];
            (&mut input[..LEN.len()]).copy_from_slice(&LEN);
            (&mut input[LEN.len()..]).copy_from_slice(&EXPECTED);
            input
        }};
    }

    #[test]
    fn deserialize_str() -> Result<()> {
        const EXPECTED: &[u8] = b"Without nature's limits, humanity's true nature was revealed.";
        let input = input!(EXPECTED);
        let actual: &str = from_slice(input.as_slice())?;
        let expected = std::str::from_utf8(EXPECTED).unwrap();
        assert_eq!(expected, actual);
        Ok(())
    }

    #[test]
    fn deserialize_string() -> Result<()> {
        let vec: Vec<u8> = vec![
            0x06, 0x00, 0x00, 0x00, 'l' as u8, 'o' as u8, 'c' as u8, 'a' as u8, 's' as u8,
            'h' as u8,
        ];
        let result: Result<String> = from_vec(&vec);
        assert_eq!("locash", result?);
        Ok(())
    }

    #[test]
    fn deserialize_bytes() -> Result<()> {
        const EXPECTED: &[u8] = b"I have altered the API, pray I don't alter it any further.";
        let input = input!(EXPECTED);
        let actual: &[u8] = from_slice(input.as_slice())?;
        assert_eq!(EXPECTED, actual);
        Ok(())
    }

    #[test]
    fn deserialize_byte_buf() -> Result<()> {
        let vec: Vec<u8> = vec![0x04, 0x00, 0x00, 0x00, 0x42, 0x91, 0xBE, 0xEF];
        let result: Result<Vec<u8>> = from_vec(&vec);
        assert_eq!(&vec[4..], result?);
        Ok(())
    }

    #[test]
    fn deserialize_none() -> Result<()> {
        let vec: Vec<u8> = vec![0x00];
        let result: Result<Option<u8>> = from_vec(&vec);
        assert_eq!(None, result?);
        Ok(())
    }

    #[test]
    fn deserialize_some() -> Result<()> {
        let vec: Vec<u8> = vec![0x01, 0xD5];
        let result: Result<Option<u8>> = from_vec(&vec);
        assert_eq!(Some(0xD5u8), result?);
        Ok(())
    }

    #[test]
    fn deserialize_tuple() -> Result<()> {
        let expected = ("orb".to_string(), 12u16);
        let vec: Vec<u8> = vec![
            0x03, 0x00, 0x00, 0x00, 'o' as u8, 'r' as u8, 'b' as u8, 0x0C, 0x00,
        ];
        let result = from_vec(&vec);
        assert_eq!(expected, result?);
        Ok(())
    }

    #[test]
    fn deserialize_map() -> Result<()> {
        let expected: HashMap<String, u8> =
            HashMap::from([("blue".to_string(), 5), ("red".to_string(), 7)]);
        let vec: Vec<u8> = vec![
            0x02, 0x00, 0x00, 0x00, // Number of entries in the map.
            0x04, 0x00, 0x00, 0x00, 'b' as u8, 'l' as u8, 'u' as u8, 'e' as u8, // First key.
            0x05,      // First value.
            0x03, 0x00, 0x00, 0x00, 'r' as u8, 'e' as u8, 'd' as u8, // Second key.
            0x07,      // Second value.
        ];
        let result = from_vec(&vec);
        assert_eq!(expected, result?);
        Ok(())
    }

    #[test]
    fn deserialize_struct() -> Result<()> {
        #[derive(Debug, PartialEq, Deserialize)]
        struct Order {
            customer: String,
            item_id: u16,
            quantity: u8,
        }
        let expected = Order {
            customer: "Bob".to_string(),
            item_id: 256,
            quantity: 255,
        };
        let vec: Vec<u8> = vec![
            0x03, 0x00, 0x00, 0x00, 'B' as u8, 'o' as u8, 'b' as u8, 0x00, 0x01, 0xFF,
        ];
        let result = from_vec(&vec);
        assert_eq!(expected, result?);
        Ok(())
    }

    #[test]
    fn deserialize_enum() -> Result<()> {
        #[derive(Debug, PartialEq, Deserialize)]
        enum Emotions {
            Anguish,
            Catharsis,
        }
        let vec: Vec<u8> = vec![0x01, 0x00];
        let result = from_vec(&vec);
        assert_eq!(Emotions::Catharsis, result?);
        Ok(())
    }

    #[test]
    fn deserialize_struct_variant() -> Result<()> {
        #[derive(Debug, PartialEq, Deserialize)]
        enum Vector {
            Dim2(i32, i32),
            Dim3(i32, i32, i32),
        }
        let expected = Vector::Dim3(1, -1, -2);
        let vec: Vec<u8> = vec![
            0x01, 0x00, // The variant index.
            0x01, 0x00, 0x00, 0x00, // The first entry.
            0xFF, 0xFF, 0xFF, 0xFF, // The second entry.
            0xFE, 0xFF, 0xFF, 0xFF, // The last entry.
        ];
        let result = from_vec(&vec);
        assert_eq!(expected, result?);
        Ok(())
    }

    #[test]
    fn deserialize_socket_addr() -> Result<()> {
        use std::net::{IpAddr, Ipv6Addr, SocketAddr};
        let expected = SocketAddr::new(IpAddr::V6(Ipv6Addr::LOCALHOST), 1337);
        let vec = to_vec(&expected)?;

        let actual = from_vec(&vec)?;

        assert_eq!(expected, actual);
        Ok(())
    }
}