serde_amqp 0.14.1

//! Deserializer implementation

use serde::{
    de::{self},
    Deserialize,
};
use std::convert::TryInto;

use crate::{
    __constants::{
        ARRAY, DECIMAL128, DECIMAL32, DECIMAL64, DESCRIBED_BASIC, DESCRIBED_LIST, DESCRIBED_MAP,
        DESCRIPTOR, LAZY_VALUE, SYMBOL, SYMBOL_REF, TIMESTAMP, TRANSPARENT_VEC, UUID, VALUE,
    },
    descriptor::PeekDescriptor,
    error::Error,
    fixed_width::{DECIMAL128_WIDTH, DECIMAL32_WIDTH, DECIMAL64_WIDTH, UUID_WIDTH},
    format::{
        OFFSET_ARRAY32, OFFSET_ARRAY8, OFFSET_LIST32, OFFSET_LIST8, OFFSET_MAP32, OFFSET_MAP8,
    },
    format_code::EncodingCodes,
    read::{IoReader, Read, SliceReader},
    util::{EnumType, NonNativeType, PeekTypeCode, SequenceType, StructEncoding},
};

/// Maximum number of elements an array, list, or map declared on the wire is
/// allowed to claim before the deserializer rejects the frame.
///
/// AMQP `array8`/`array32`, `list8`/`list32`, and `map8`/`map32` all carry an
/// element/entry count read directly from the network. Without an upper bound,
/// a single 39-byte frame can declare `2^31` elements with a zero-width
/// element format code (e.g. `null`/`boolean-true`/`uint0`) and force the
/// decoder to iterate or allocate `2^31` times, which is an unauthenticated
/// DoS. The cap is well above any legitimate AMQP traffic seen in practice —
/// real-world OPEN/BEGIN/ATTACH frames carry single-digit element counts.
pub const MAX_ARRAY_COUNT: usize = 65_536;

/// Deserialize an instance of type T from an IO stream
pub fn from_reader<T: de::DeserializeOwned>(reader: impl std::io::Read) -> Result<T, Error> {
    let reader = IoReader::new(reader);
    let mut de = Deserializer::new(reader);
    T::deserialize(&mut de)
}

/// Deserialize and instance of type T from a bytes slice
pub fn from_slice<'de, T: de::Deserialize<'de>>(slice: &'de [u8]) -> Result<T, Error> {
    let reader = SliceReader::new(slice);
    let mut de = Deserializer::new(reader);
    T::deserialize(&mut de)
}

/// A structure that deserializes AMQP1.0 binary encoded values into rust types
#[derive(Debug)]
pub struct Deserializer<R> {
    reader: R,
    non_native_type: Option<NonNativeType>,
    seq_type: Option<SequenceType>,
    enum_type: EnumType,
    struct_encoding: StructEncoding,
    elem_format_code: Option<EncodingCodes>,
}

impl<'de, R: Read<'de>> Deserializer<R> {
    /// Creates a new AMQP1.0 (crate)deserializer
    pub fn new(reader: R) -> Self {
        Self {
            reader,
            non_native_type: None,
            seq_type: None,
            enum_type: Default::default(),
            struct_encoding: StructEncoding::None,
            elem_format_code: None,
        }
    }

    fn read_format_code(&mut self) -> Option<Result<EncodingCodes, Error>> {
        self.reader
            .next()
            .map_err(Into::into)
            .transpose()
            .map(|code| code.and_then(|code| code.try_into()))
    }

    fn get_elem_code_or_read_format_code(&mut self) -> Option<Result<EncodingCodes, Error>> {
        match &self.elem_format_code {
            Some(c) => Some(Ok(c.clone())),
            None => self.read_format_code(),
        }
    }

    fn get_elem_code_or_peek_byte(&mut self) -> Option<Result<u8, Error>> {
        match &self.elem_format_code {
            Some(c) => Some(Ok(c.clone() as u8)),
            None => self.reader.peek().map(Ok),
        }
    }

    #[inline]
    fn parse_bool(&mut self) -> Result<bool, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_bool"))??
        {
            EncodingCodes::Boolean => {
                let byte =
                    self.reader.next().map_err(Into::into).and_then(|b| {
                        b.ok_or_else(|| Error::unexpected_eof("Expecting bool byte"))
                    })?;
                match byte {
                    0x00 => Ok(false),
                    0x01 => Ok(true),
                    _ => Err(Error::InvalidValue),
                }
            }
            EncodingCodes::BooleanTrue => Ok(true),
            EncodingCodes::BooleanFalse => Ok(false),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_i8(&mut self) -> Result<i8, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_i8"))??
        {
            EncodingCodes::Byte => {
                let byte = self
                    .reader
                    .next()
                    .map_err(Into::into)
                    .and_then(|b| b.ok_or_else(|| Error::unexpected_eof("Expecting i8")))?;
                Ok(byte as i8)
            }
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_i16(&mut self) -> Result<i16, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_i16"))??
        {
            EncodingCodes::Short => self
                .reader
                .read_const_bytes()
                .map(i16::from_be_bytes)
                .map_err(Into::into),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_i32(&mut self) -> Result<i32, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_i32"))??
        {
            EncodingCodes::Int => self
                .reader
                .read_const_bytes()
                .map(i32::from_be_bytes)
                .map_err(Into::into),
            EncodingCodes::SmallInt => self.reader.next().map_err(Into::into).and_then(|b| {
                b.map(|signed| signed as i8 as i32)
                    .ok_or_else(|| Error::unexpected_eof("Expecting i32"))
            }),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_i64(&mut self) -> Result<i64, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_i64"))??
        {
            EncodingCodes::Long => self
                .reader
                .read_const_bytes()
                .map(i64::from_be_bytes)
                .map_err(Into::into),
            EncodingCodes::SmallLong => self.reader.next().map_err(Into::into).and_then(|b| {
                b.map(|signed| signed as i8 as i64)
                    .ok_or_else(|| Error::unexpected_eof("Expecting i64"))
            }),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_u8(&mut self) -> Result<u8, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_u8"))??
        {
            EncodingCodes::Ubyte => self
                .reader
                .next()
                .map_err(Into::into)
                .and_then(|b| b.ok_or_else(|| Error::unexpected_eof("Expecting u8"))),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_u16(&mut self) -> Result<u16, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_u16"))??
        {
            EncodingCodes::Ushort => self
                .reader
                .read_const_bytes()
                .map(u16::from_be_bytes)
                .map_err(Into::into),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_u32(&mut self) -> Result<u32, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_u32"))??
        {
            EncodingCodes::Uint => self
                .reader
                .read_const_bytes()
                .map(u32::from_be_bytes)
                .map_err(Into::into),
            EncodingCodes::SmallUint => self.reader.next().map_err(Into::into).and_then(|b| {
                b.ok_or_else(|| Error::unexpected_eof("Expecting small u32"))
                    .map(|byte| byte as u32)
            }),
            EncodingCodes::Uint0 => Ok(0),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_u64(&mut self) -> Result<u64, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_u64"))??
        {
            EncodingCodes::Ulong => {
                let bytes = self.reader.read_const_bytes()?;
                Ok(u64::from_be_bytes(bytes))
            }
            EncodingCodes::SmallUlong => {
                let byte = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting small u64"))?;
                Ok(byte as u64)
            }
            EncodingCodes::Ulong0 => Ok(0),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_f32(&mut self) -> Result<f32, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_f32"))??
        {
            EncodingCodes::Float => {
                let bytes = self.reader.read_const_bytes()?;
                Ok(f32::from_be_bytes(bytes))
            }
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_f64(&mut self) -> Result<f64, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_f64"))??
        {
            EncodingCodes::Double => {
                let bytes = self.reader.read_const_bytes()?;
                Ok(f64::from_be_bytes(bytes))
            }
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_char(&mut self) -> Result<char, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_char"))??
        {
            EncodingCodes::Char => {
                let bytes = self.reader.read_const_bytes()?;
                let n = u32::from_be_bytes(bytes);
                char::from_u32(n).ok_or(Error::InvalidValue)
            }
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn read_small_string(&mut self) -> Option<Result<String, Error>> {
        let len = match self.reader.next().transpose() {
            Some(Ok(byte)) => byte,
            Some(Err(e)) => return Some(Err(e.into())),
            None => return None,
        };
        match self.reader.read_bytes(len as usize) {
            Ok(buf) => Some(String::from_utf8(buf).map_err(Into::into)),
            Err(e) => Some(Err(e.into())),
        }
    }

    #[inline]
    fn read_string(&mut self) -> Option<Result<String, Error>> {
        let len_bytes = match self.reader.read_const_bytes() {
            Ok(bytes) => bytes,
            Err(e) => return Some(Err(e.into())),
        };
        let len = u32::from_be_bytes(len_bytes);
        match self.reader.read_bytes(len as usize) {
            Ok(buf) => Some(String::from_utf8(buf).map_err(Into::into)),
            Err(e) => Some(Err(e.into())),
        }
    }

    #[inline]
    fn parse_string(&mut self) -> Result<String, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_string"))??
        {
            EncodingCodes::Str8 => self
                .read_small_string()
                .ok_or_else(|| Error::unexpected_eof("Expecting str8"))?,
            EncodingCodes::Str32 => self
                .read_string()
                .ok_or_else(|| Error::unexpected_eof("Expecting str32"))?,
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_symbol(&mut self) -> Result<String, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_symbol"))??
        {
            EncodingCodes::Sym8 => self
                .read_small_string()
                .ok_or_else(|| Error::unexpected_eof("Expecting sym8"))?,
            EncodingCodes::Sym32 => self
                .read_string()
                .ok_or_else(|| Error::unexpected_eof("Expecting sym32"))?,
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_binary(&mut self) -> Result<Vec<u8>, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_byte_buf"))??
        {
            EncodingCodes::Vbin8 => {
                let len = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting len"))?;
                self.reader.read_bytes(len as usize).map_err(Into::into)
            }
            EncodingCodes::Vbin32 => {
                let len_bytes = self.reader.read_const_bytes()?;
                let len = u32::from_be_bytes(len_bytes);
                self.reader.read_bytes(len as usize).map_err(Into::into)
            }
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_decimal<V>(&mut self, visitor: V) -> Result<V::Value, Error>
    where
        V: de::Visitor<'de>,
    {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_decimal"))??
        {
            EncodingCodes::Decimal32 => self
                .reader
                .forward_read_bytes_with_hint(DECIMAL32_WIDTH, visitor),
            EncodingCodes::Decimal64 => self
                .reader
                .forward_read_bytes_with_hint(DECIMAL64_WIDTH, visitor),
            EncodingCodes::Decimal128 => self
                .reader
                .forward_read_bytes_with_hint(DECIMAL128_WIDTH, visitor),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_uuid<V>(&mut self, visitor: V) -> Result<V::Value, Error>
    where
        V: de::Visitor<'de>,
    {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_uuid"))??
        {
            EncodingCodes::Uuid => self
                .reader
                .forward_read_bytes_with_hint(UUID_WIDTH, visitor),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_timestamp(&mut self) -> Result<i64, Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_timestamp"))??
        {
            EncodingCodes::Timestamp => {
                let bytes = self.reader.read_const_bytes()?;
                Ok(i64::from_be_bytes(bytes))
            }
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_unit(&mut self) -> Result<(), Error> {
        match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("parse_unit"))??
        {
            EncodingCodes::Null => Ok(()),
            _ => Err(Error::InvalidFormatCode),
        }
    }

    #[inline]
    fn parse_described_identifier<V>(&mut self, visitor: V) -> Result<V::Value, Error>
    where
        V: de::Visitor<'de>,
    {
        // [0] is 0x00,
        // [1] is format code
        let buf = self
            .reader
            .peek_bytes(2)?
            .ok_or_else(|| Error::unexpected_eof("parse_described_identifier"))?;
        let code = buf[1];
        match code.try_into()? {
            EncodingCodes::Sym8 => {
                // [0] is 0x00,
                // [1] is format code
                // [2] is size
                let _buf = self
                    .reader
                    .peek_bytes(3)?
                    .ok_or_else(|| Error::unexpected_eof(""))?;
                let size = _buf[2] as usize;
                let _buf = self
                    .reader
                    .peek_bytes(3 + size)?
                    .ok_or_else(|| Error::unexpected_eof(""))?;
                let slice = std::str::from_utf8(&_buf[3..])?;
                visitor.visit_str(slice)
            }
            EncodingCodes::Sym32 => {
                // [0] is 0x00,
                // [1] is format code
                // [2..6] are size
                let _buf = self
                    .reader
                    .peek_bytes(2 + 4)?
                    .ok_or_else(|| Error::unexpected_eof(""))?;
                let mut size_bytes = [0u8; 4];
                size_bytes.copy_from_slice(&_buf[2..]);
                let size = u32::from_be_bytes(size_bytes) as usize;
                let _buf = self
                    .reader
                    .peek_bytes(6 + size)?
                    .ok_or_else(|| Error::unexpected_eof(""))?;
                let slice = std::str::from_utf8(&_buf[6..])?;
                visitor.visit_str(slice)
            }
            EncodingCodes::Ulong0 => visitor.visit_u64(0),
            EncodingCodes::SmallUlong => {
                // [0] is 0x00,
                // [1] is format code
                // [2] is the value
                let buf = self
                    .reader
                    .peek_bytes(3)?
                    .ok_or_else(|| Error::unexpected_eof(""))?;
                let value = buf[2];
                visitor.visit_u64(value as u64)
            }
            EncodingCodes::Ulong => {
                // [0] is 0x00,
                // [1] is format code
                // [2..10] is value bytes
                let slice = self
                    .reader
                    .peek_bytes(2 + 8)?
                    .ok_or_else(|| Error::unexpected_eof(""))?;
                let mut bytes = [0u8; 8];
                bytes.copy_from_slice(&slice[2..]);
                let value = u64::from_be_bytes(bytes);
                visitor.visit_u64(value)
            }
            _ => Err(Error::InvalidFormatCode),
        }
    }
}

impl<'de, R> de::Deserializer<'de> for &mut Deserializer<R>
where
    R: Read<'de>,
{
    type Error = Error;

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

    #[inline]
    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        // match self.reader.peek()?.try_into()? {
        match self
            .get_elem_code_or_peek_byte()
            .ok_or_else(|| Error::unexpected_eof(""))??
            .try_into()?
        {
            EncodingCodes::Boolean | EncodingCodes::BooleanFalse | EncodingCodes::BooleanTrue => {
                self.deserialize_bool(visitor)
            }
            EncodingCodes::Byte => self.deserialize_i8(visitor),
            EncodingCodes::Short => self.deserialize_i16(visitor),
            EncodingCodes::Int | EncodingCodes::SmallInt => self.deserialize_i32(visitor),
            EncodingCodes::Long | EncodingCodes::SmallLong => self.deserialize_i64(visitor),
            EncodingCodes::Ubyte => self.deserialize_u8(visitor),
            EncodingCodes::Ushort => self.deserialize_u16(visitor),
            EncodingCodes::Uint | EncodingCodes::SmallUint | EncodingCodes::Uint0 => {
                self.deserialize_u32(visitor)
            }
            EncodingCodes::Ulong | EncodingCodes::SmallUlong | EncodingCodes::Ulong0 => {
                self.deserialize_u64(visitor)
            }
            EncodingCodes::Float => self.deserialize_f32(visitor),
            EncodingCodes::Double => self.deserialize_f64(visitor),
            EncodingCodes::Char => self.deserialize_char(visitor),
            EncodingCodes::Str32 | EncodingCodes::Str8 => self.deserialize_string(visitor),
            EncodingCodes::Vbin32 | EncodingCodes::Vbin8 => self.deserialize_byte_buf(visitor),
            EncodingCodes::Null => self.deserialize_unit(visitor),

            EncodingCodes::Sym32 | EncodingCodes::Sym8 => {
                self.deserialize_newtype_struct(SYMBOL, visitor)
            }
            EncodingCodes::DescribedType => {
                // This will not handle DescribedBasic types
                self.deserialize_struct("", &[""], visitor)
            }
            EncodingCodes::Array32 | EncodingCodes::Array8 => {
                self.deserialize_newtype_struct(ARRAY, visitor)
            }
            EncodingCodes::List0 | EncodingCodes::List8 | EncodingCodes::List32 => {
                self.deserialize_seq(visitor)
            }
            EncodingCodes::Map32 | EncodingCodes::Map8 => self.deserialize_map(visitor),

            EncodingCodes::Decimal32 => self.deserialize_newtype_struct(DECIMAL32, visitor),
            EncodingCodes::Decimal64 => self.deserialize_newtype_struct(DECIMAL64, visitor),
            EncodingCodes::Decimal128 => self.deserialize_newtype_struct(DECIMAL128, visitor),
            EncodingCodes::Timestamp => self.deserialize_newtype_struct(TIMESTAMP, visitor),
            EncodingCodes::Uuid => self.deserialize_newtype_struct(UUID, visitor),
        }
    }

    #[inline]
    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_bool(self.parse_bool()?)
    }

    #[inline]
    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_i8(self.parse_i8()?)
    }

    #[inline]
    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_i16(self.parse_i16()?)
    }

    #[inline]
    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_i32(self.parse_i32()?)
    }

    #[inline]
    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        match self.non_native_type {
            Some(NonNativeType::Timestamp) => {
                self.non_native_type = None;
                visitor.visit_i64(self.parse_timestamp()?)
            }
            _ => visitor.visit_i64(self.parse_i64()?),
        }
    }

    #[inline]
    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_u8(self.parse_u8()?)
    }

    #[inline]
    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_u16(self.parse_u16()?)
    }

    #[inline]
    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_u32(self.parse_u32()?)
    }

    #[inline]
    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_u64(self.parse_u64()?)
    }

    #[inline]
    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_f32(self.parse_f32()?)
    }

    #[inline]
    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_f64(self.parse_f64()?)
    }

    #[inline]
    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        visitor.visit_char(self.parse_char()?)
    }

    #[inline]
    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        match self.non_native_type {
            Some(NonNativeType::Symbol) => {
                // Leave symbol as visit_string because serde(untagged)
                // on descriptor will visit String instead of str
                self.non_native_type = None;
                visitor.visit_string(self.parse_symbol()?)
            }
            _ => visitor.visit_string(self.parse_string()?),
        }
    }

    #[inline]
    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        let len = match self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??
        {
            EncodingCodes::Str8 | EncodingCodes::Sym8 => {
                self.reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting len"))? as usize
            }
            EncodingCodes::Str32 | EncodingCodes::Sym32 => {
                self.reader.read_const_bytes().map(u32::from_be_bytes)? as usize
            }
            _ => return Err(Error::InvalidFormatCode),
        };
        self.reader.forward_read_str(len, visitor)
    }

    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        // visitor.visit_byte_buf(self.parse_byte_buf()?)
        match self.non_native_type {
            None => visitor.visit_byte_buf(self.parse_binary()?),
            Some(NonNativeType::LazyValue) => self.reader.forward_read_byte_buf(visitor),
            _ => unreachable!("Only Binary and LazyValue are expected in deserialize_byte_buf"),
        }
    }

    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        match self.non_native_type {
            // Use bytes to reduce number of memcpy
            Some(NonNativeType::Dec32)
            | Some(NonNativeType::Dec64)
            | Some(NonNativeType::Dec128) => {
                self.non_native_type = None;
                self.parse_decimal(visitor)
            }
            // Use bytes to reduce number of memcpy
            Some(NonNativeType::Uuid) => {
                self.non_native_type = None;
                self.parse_uuid(visitor)
            }
            Some(NonNativeType::LazyValue) => {
                unreachable!()
            }
            _ => {
                let len = match self
                    .get_elem_code_or_read_format_code()
                    .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??
                {
                    EncodingCodes::Vbin8 => self
                        .reader
                        .next()?
                        .ok_or_else(|| Error::unexpected_eof("Expecting len"))?
                        as usize,
                    EncodingCodes::Vbin32 => {
                        self.reader.read_const_bytes().map(u32::from_be_bytes)? as usize
                    }
                    _ => return Err(Error::InvalidFormatCode),
                };
                self.reader.forward_read_bytes_with_hint(len, visitor)
            }
        }
    }

    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        match self
            .get_elem_code_or_peek_byte()
            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??
            .try_into()?
        {
            EncodingCodes::Null => {
                // consume the Null byte
                let _ = self
                    .get_elem_code_or_read_format_code()
                    .ok_or_else(|| Error::unexpected_eof("Expecting len"))?;
                visitor.visit_none()
            }
            _ => visitor.visit_some(self),
        }
    }

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

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

    fn deserialize_newtype_struct<V>(
        self,
        name: &'static str,
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        if name == SYMBOL {
            self.non_native_type = Some(NonNativeType::Symbol);
            // Leave symbol as visit_string because serde(untagged)
            // on descriptor will visit String instead of str
            self.deserialize_string(visitor)
        } else if name == SYMBOL_REF {
            self.non_native_type = Some(NonNativeType::SymbolRef);
            self.deserialize_str(visitor)
        } else if name == DECIMAL32 {
            self.non_native_type = Some(NonNativeType::Dec32);
            self.deserialize_bytes(visitor)
        } else if name == DECIMAL64 {
            self.non_native_type = Some(NonNativeType::Dec64);
            self.deserialize_bytes(visitor)
        } else if name == DECIMAL128 {
            self.non_native_type = Some(NonNativeType::Dec128);
            self.deserialize_bytes(visitor)
        } else if name == UUID {
            self.non_native_type = Some(NonNativeType::Uuid);
            self.deserialize_bytes(visitor)
        } else if name == TIMESTAMP {
            self.non_native_type = Some(NonNativeType::Timestamp);
            self.deserialize_i64(visitor)
        } else if name == TRANSPARENT_VEC {
            self.seq_type = Some(SequenceType::TransparentVec);
            visitor.visit_seq(TransparentVecAccess::new(self))
        } else if name == LAZY_VALUE {
            self.non_native_type = Some(NonNativeType::LazyValue);
            self.deserialize_byte_buf(visitor)
        } else {
            visitor.visit_newtype_struct(self)
        }
    }

    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        let code = self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??;
        match code {
            EncodingCodes::Array8 => {
                // Read "header" bytes
                let len = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting len"))?
                    as usize;
                let count = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting count"))?
                    as usize;

                // Reject counts that exceed the hard cap or the encoded body
                // length. Without these checks an attacker could supply a
                // count larger than the bytes actually present (in particular
                // with zero-width element format codes such as null/true/
                // false/uint0/ulong0) and force the visitor to iterate or
                // allocate far beyond the frame size.
                if count > MAX_ARRAY_COUNT || count > len {
                    return Err(Error::InvalidValue);
                }

                // If count is zero, jump to visitor
                match count {
                    0 => visitor.visit_seq(ArrayAccess::new(self, len, count)),
                    _ => {
                        let format_code = self
                            .read_format_code()
                            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??;
                        self.elem_format_code = Some(format_code);

                        // Account for offset
                        let len = len - OFFSET_ARRAY8;
                        // let buf = self.reader.read_bytes(len)?;

                        visitor.visit_seq(ArrayAccess::new(self, len, count))
                    }
                }
            }
            EncodingCodes::Array32 => {
                // Read "header" bytes
                let len_bytes = self.reader.read_const_bytes()?;
                let len = u32::from_be_bytes(len_bytes) as usize;

                let count_bytes = self.reader.read_const_bytes()?;
                let count = u32::from_be_bytes(count_bytes) as usize;

                // See `Array8` arm above: cap the count so that a malformed
                // frame cannot trick the visitor into iterating 2^31 times.
                if count > MAX_ARRAY_COUNT || count > len {
                    return Err(Error::InvalidValue);
                }

                // If count is zero, jump to visitor
                match count {
                    0 => visitor.visit_seq(ArrayAccess::new(self, len, count)),
                    _ => {
                        let format_code = self
                            .read_format_code()
                            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??;
                        self.elem_format_code = Some(format_code);

                        // Account for offset
                        let len = len - OFFSET_ARRAY32;
                        // let buf = self.reader.read_bytes(len)?;

                        visitor.visit_seq(ArrayAccess::new(self, len, count))
                    }
                }
            }
            EncodingCodes::List0 => {
                let len = 0;
                let count = 0;
                visitor.visit_seq(ListAccess::new(self, len, count))
            }
            EncodingCodes::List8 => {
                let len = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting len"))?
                    as usize;
                let count = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting count"))?
                    as usize;

                // Account for offset
                let len = len - OFFSET_LIST8;

                // Make sure there is no other element format code
                self.elem_format_code = None;
                visitor.visit_seq(ListAccess::new(self, len, count))
            }
            EncodingCodes::List32 => {
                let len_bytes = self.reader.read_const_bytes()?;
                let count_bytes = self.reader.read_const_bytes()?;
                let len = u32::from_be_bytes(len_bytes) as usize;
                let count = u32::from_be_bytes(count_bytes) as usize;

                // Defense in depth: each list element carries its own format
                // code (>=1 byte), so a valid `list32` is implicitly bounded
                // by frame size. We still cap `count` to keep allocation and
                // iteration costs in check for unauthenticated frames.
                if count > MAX_ARRAY_COUNT {
                    return Err(Error::InvalidValue);
                }

                // Account for offset
                let len = len - OFFSET_LIST32;

                // Make sure there is no other element format code
                self.elem_format_code = None;
                visitor.visit_seq(ListAccess::new(self, len, count))
            }
            _ => Err(Error::InvalidFormatCode),
        }
    }

    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        // Tuple will always be deserialized as List
        let code = self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??;

        let (size, count) = match code {
            EncodingCodes::List0 => {
                let size = 0;
                let count = 0;
                (size, count)
            }
            EncodingCodes::List8 => {
                let size = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting size"))?
                    as usize;
                let count = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting count"))?
                    as usize;

                // Account for offset
                let size = size - OFFSET_LIST8;

                // Make sure there is no other element format code
                self.elem_format_code = None;
                (size, count)
            }
            EncodingCodes::List32 => {
                let size_bytes = self.reader.read_const_bytes()?;
                let count_bytes = self.reader.read_const_bytes()?;
                let size = u32::from_be_bytes(size_bytes) as usize;
                let count = u32::from_be_bytes(count_bytes) as usize;

                // Account for offset
                let size = size - OFFSET_LIST32;

                // Make sure there is no other element format code
                self.elem_format_code = None;
                (size, count)
            }
            _ => return Err(Error::InvalidFormatCode),
        };

        if count != len {
            return Err(Error::SequenceLengthMismatch);
        }

        visitor.visit_seq(ListAccess::new(self, size, count))
    }

    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        let code = self
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??;
        let (size, count) = match code {
            EncodingCodes::Map8 => {
                let size = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting size"))?
                    as usize;
                let count = self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting count"))?
                    as usize;

                // Account for offset
                let size = size - OFFSET_MAP8;

                (size, count)
            }
            EncodingCodes::Map32 => {
                let size_bytes = self.reader.read_const_bytes()?;
                let count_bytes = self.reader.read_const_bytes()?;

                let size = u32::from_be_bytes(size_bytes) as usize;
                let count = u32::from_be_bytes(count_bytes) as usize;

                // Cap the count for the same reasons as in the array path:
                // a `map32` whose count is larger than any plausible
                // legitimate frame is treated as malformed.
                if count > MAX_ARRAY_COUNT {
                    return Err(Error::InvalidValue);
                }

                // Account for offset
                let size = size - OFFSET_MAP32;

                (size, count)
            }
            _ => return Err(Error::InvalidFormatCode),
        };

        // // AMQP map count includes both key and value, should be halfed
        // let count = count / 2;
        visitor.visit_map(MapAccess::new(self, size, count))
    }

    fn deserialize_tuple_struct<V>(
        self,
        name: &'static str,
        len: usize,
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        if name == DESCRIBED_BASIC {
            self.struct_encoding = StructEncoding::DescribedBasic;
            visitor.visit_seq(DescribedAccess::basic(self, len as u32))
        } else if name == DESCRIBED_LIST {
            self.struct_encoding = StructEncoding::DescribedList;
            visitor.visit_seq(DescribedAccess::list(self))
        } else {
            match self
                .get_elem_code_or_peek_byte()
                .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??
                .try_into()?
            {
                EncodingCodes::DescribedType => visitor.visit_seq(DescribedAccess::list(self)),
                _ => self.deserialize_tuple(len, visitor),
            }
        }
    }

    fn deserialize_struct<V>(
        self,
        name: &'static str,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        // The name should override parent struct encoding
        let cur_encoding = self.struct_encoding.clone();
        let result = if name == DESCRIBED_BASIC {
            self.struct_encoding = StructEncoding::DescribedBasic;
            visitor.visit_seq(DescribedAccess::basic(self, fields.len() as u32))
        } else if name == DESCRIBED_LIST {
            self.struct_encoding = StructEncoding::DescribedList;
            visitor.visit_seq(DescribedAccess::list(self))
        } else if name == DESCRIBED_MAP {
            self.struct_encoding = StructEncoding::DescribedMap;
            visitor.visit_map(DescribedAccess::map(self))
        } else {
            self.struct_encoding = StructEncoding::None;
            match self
                .get_elem_code_or_peek_byte()
                .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??
                .try_into()?
            {
                EncodingCodes::List0 | EncodingCodes::List32 | EncodingCodes::List8 => {
                    self.deserialize_tuple(fields.len(), visitor)
                }
                EncodingCodes::Map32 | EncodingCodes::Map8 => self.deserialize_map(visitor),
                EncodingCodes::DescribedType => visitor.visit_seq(DescribedAccess::list(self)),
                _ => Err(Error::InvalidFormatCode),
            }
        };
        // Restore
        self.struct_encoding = cur_encoding;
        result
    }

    fn deserialize_enum<V>(
        self,
        name: &'static str,
        _variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        use crate::__constants::UNTAGGED_ENUM;

        let curr_enum_type = self.enum_type.clone();

        let result = if name == VALUE {
            self.enum_type = EnumType::Value;
            visitor.visit_enum(VariantAccess::new(self))
        } else if name == DESCRIPTOR {
            self.enum_type = EnumType::Descriptor;
            visitor.visit_enum(VariantAccess::new(self))
        } else if name == UNTAGGED_ENUM {
            visitor.visit_enum(VariantAccess::new(self))
        } else if name == ARRAY {
            self.enum_type = EnumType::Array;
            visitor.visit_enum(VariantAccess::new(self))
        } else {
            // Considering the following enum serialization format
            // `unit_variant` - a single u32
            // generic `newtype_variant` - List([u32, Value])
            // `tuple_variant` and `struct_variant` - List([u32, List([Value, *])])
            match self
                .get_elem_code_or_peek_byte()
                .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??
                .try_into()?
            {
                EncodingCodes::Uint | EncodingCodes::Uint0 | EncodingCodes::SmallUint => {
                    visitor.visit_enum(VariantAccess::new(self))
                }
                EncodingCodes::List0 => Err(Error::InvalidFormatCode),
                EncodingCodes::List8 | EncodingCodes::Map8 => {
                    let _code = self
                        .reader
                        .next()?
                        .ok_or_else(|| Error::unexpected_eof("Expecting code"))?;
                    let _size = self
                        .reader
                        .next()?
                        .ok_or_else(|| Error::unexpected_eof("Expecting code"))?
                        as usize;
                    let count = self
                        .reader
                        .next()?
                        .ok_or_else(|| Error::unexpected_eof("Expecting count"))?
                        as usize;
                    if count != 2 {
                        return Err(Error::InvalidLength);
                    }
                    visitor.visit_enum(VariantAccess::new(self))
                }
                EncodingCodes::List32 | EncodingCodes::Map32 => {
                    let _code = self
                        .reader
                        .next()?
                        .ok_or_else(|| Error::unexpected_eof("Expecting code"))?;
                    let size_bytes = self.reader.read_const_bytes()?;
                    let _size = u32::from_be_bytes(size_bytes);
                    let count_bytes = self.reader.read_const_bytes()?;
                    let count = u32::from_be_bytes(count_bytes);

                    if count != 2 {
                        return Err(Error::InvalidLength);
                    }
                    visitor.visit_enum(VariantAccess::new(self))
                }
                // Symbols appears in the transport errors
                EncodingCodes::Sym32 | EncodingCodes::Sym8 => {
                    visitor.visit_enum(VariantAccess::new(self))
                }
                // for newtype variant of described type
                EncodingCodes::DescribedType => visitor.visit_enum(VariantAccess::new(self)),
                _ => visitor.visit_enum(VariantAccess::new(self)),
            }
        };

        // Revert self.enum_type
        self.enum_type = curr_enum_type;

        result
    }

    // an identifier is either a field of a struct or a variant of an eunm
    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        match self.enum_type {
            EnumType::Value => {
                let code = self
                    .get_elem_code_or_peek_byte()
                    .ok_or_else(|| Error::unexpected_eof(""))??;
                visitor.visit_u8(code)
            }
            EnumType::Descriptor => {
                // Consume the EncodingCodes::Described byte
                match self
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting format code"))?
                    .try_into()?
                {
                    EncodingCodes::DescribedType => {}
                    _ => return Err(Error::InvalidFormatCode),
                };
                // Reset the enum type
                self.enum_type = EnumType::None;
                let code = self
                    .get_elem_code_or_peek_byte()
                    .ok_or_else(|| Error::unexpected_eof(""))??;
                visitor.visit_u8(code)
            }
            EnumType::Array => {
                let code = self
                    .get_elem_code_or_peek_byte()
                    .ok_or_else(|| Error::unexpected_eof(""))??;
                visitor.visit_u8(code)
            }
            EnumType::None => {
                // The following are the possible identifiers
                let code = self
                    .get_elem_code_or_peek_byte()
                    .ok_or_else(|| Error::unexpected_eof(""))??;
                match code.try_into()? {
                    // If a struct is serialized as a map, then the fields are serialized as str
                    EncodingCodes::Str32 | EncodingCodes::Str8 => self.deserialize_str(visitor),
                    // FIXME: Enum variant currently are serialzied as list of with variant index and a list
                    EncodingCodes::Uint | EncodingCodes::SmallUint | EncodingCodes::Uint0 => {
                        self.deserialize_u32(visitor)
                    }
                    // Potentially using `Descriptor::Name` as identifier
                    EncodingCodes::Sym32 | EncodingCodes::Sym8 => {
                        self.deserialize_newtype_struct(SYMBOL, visitor)
                    }
                    // Potentially using `Descriptor::Code` as identifier
                    EncodingCodes::Ulong | EncodingCodes::SmallUlong | EncodingCodes::Ulong0 => {
                        self.deserialize_u64(visitor)
                    }
                    // Other types should not be used to serialize identifiers
                    EncodingCodes::DescribedType => self.parse_described_identifier(visitor),
                    // _ => Err(Error::InvalidFormatCode),
                    _ => visitor.visit_u8(code),
                }
            }
        }
    }

    // Use this to peek inside the buffer without consuming the bytes
    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: de::Visitor<'de>,
    {
        // The deserializer will only peek the next u8
        let code = self
            .reader
            .peek()
            .ok_or_else(|| Error::unexpected_eof(""))?;
        match code.try_into()? {
            EncodingCodes::DescribedType => self.parse_described_identifier(visitor),
            _ => visitor.visit_u8(code),
        }
    }
}

/// Accessor for array type.
///
/// Holds the residual budget for an `array8`/`array32` body so iteration can
/// be bounded both by element count and by bytes consumed. The pre-loop
/// `count <= len` and `count <= MAX_ARRAY_COUNT` checks in
/// [`Deserializer::deserialize_seq`] are the primary DoS defense; the
/// per-element overrun check in [`Self::next_element_seed`] guards against
/// drift between the encoded body length and what the element visitor
/// actually reads.
#[derive(Debug)]
pub struct ArrayAccess<'a, R> {
    de: &'a mut Deserializer<R>,
    /// Number of bytes the array body is allowed to span past `start_pos`.
    /// For `array8`/`array32` bodies this is the size field with the
    /// `OFFSET_ARRAY*` (count + element format code) header subtracted.
    size: usize,
    /// Remaining elements to yield from `next_element_seed`.
    count: usize,
    /// Snapshot of `Read::bytes_consumed` taken at construction time, i.e.
    /// the offset of the first element body. Used as the anchor for the
    /// `consumed > size` overrun check.
    start_pos: usize,
}

impl<'a, 'de, R: Read<'de>> ArrayAccess<'a, R> {
    pub(crate) fn new(de: &'a mut Deserializer<R>, size: usize, count: usize) -> Self {
        let start_pos = de.reader.bytes_consumed();
        Self {
            de,
            size,
            count,
            start_pos,
        }
    }
}

impl<R> AsMut<Deserializer<R>> for ArrayAccess<'_, R> {
    fn as_mut(&mut self) -> &mut Deserializer<R> {
        self.de
    }
}

impl<'de, R: Read<'de>> de::SeqAccess<'de> for ArrayAccess<'_, R> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
    where
        T: de::DeserializeSeed<'de>,
    {
        match self.count {
            0 => {
                self.de.elem_format_code = None;
                Ok(None)
            }
            _ => {
                self.count -= 1;
                let result = seed.deserialize(self.as_mut())?;
                // Defense in depth: bound iteration by bytes consumed, not
                // just by `count`. The pre-loop `count <= len` /
                // `count <= MAX_ARRAY_COUNT` checks already reject the known
                // attack shape (oversized count with zero-width element
                // codes). This second check fires if a future zero-width
                // element type is added, or if a visitor's element decoder
                // ever drifts past the advertised body length. Pure
                // zero-width iteration consumes 0 bytes/element so this
                // check stays quiet for the legitimate case.
                let consumed = self
                    .de
                    .reader
                    .bytes_consumed()
                    .saturating_sub(self.start_pos);
                if consumed > self.size {
                    return Err(Error::InvalidValue);
                }
                Ok(Some(result))
            }
        }
    }
}

/// Accessor for list type
#[derive(Debug)]
pub struct ListAccess<'a, R> {
    de: &'a mut Deserializer<R>,
    _size: usize,
    count: usize,
}

impl<'a, R> ListAccess<'a, R> {
    pub(crate) fn new(de: &'a mut Deserializer<R>, size: usize, count: usize) -> Self {
        Self {
            de,
            _size: size,
            count,
        }
    }
}

impl<R> AsMut<Deserializer<R>> for ListAccess<'_, R> {
    fn as_mut(&mut self) -> &mut Deserializer<R> {
        self.de
    }
}

impl<'de, R: Read<'de>> de::SeqAccess<'de> for ListAccess<'_, R> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
    where
        T: de::DeserializeSeed<'de>,
    {
        match self.count {
            0 => Ok(None),
            _ => {
                self.count -= 1;
                seed.deserialize(self.as_mut()).map(Some)
            }
        }
    }
}

/// Accessor for transparent vec type
#[derive(Debug)]
pub struct TransparentVecAccess<'a, R> {
    de: &'a mut Deserializer<R>,
    cached: Option<PeekTypeCode>,
}

impl<'a, R> TransparentVecAccess<'a, R> {
    pub(crate) fn new(de: &'a mut Deserializer<R>) -> Self {
        Self { de, cached: None }
    }
}

impl<R> AsMut<Deserializer<R>> for TransparentVecAccess<'_, R> {
    fn as_mut(&mut self) -> &mut Deserializer<R> {
        self.de
    }
}

impl<'de, R: Read<'de>> de::SeqAccess<'de> for TransparentVecAccess<'_, R> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
    where
        T: de::DeserializeSeed<'de>,
    {
        match self.de.reader.peek().map(|b| b.try_into()).transpose()? {
            Some(EncodingCodes::DescribedType) => {
                let peek = PeekDescriptor::deserialize(self.as_mut())?;
                let peek = PeekTypeCode::Composite(peek);
                match &self.cached {
                    Some(cached) => {
                        if *cached != peek {
                            return Ok(None); // Treat as end of vec
                        }
                    }
                    None => self.cached = Some(peek),
                }
            }
            Some(code) => {
                let peek = PeekTypeCode::Primitive(code.into());
                match &self.cached {
                    Some(cached) => {
                        if *cached != peek {
                            return Ok(None); // Treat as end of vec
                        }
                    }
                    None => self.cached = Some(peek),
                }
            }
            None => return Ok(None),
        }

        seed.deserialize(self.as_mut()).map(Some)
    }
}

/// Accessor for map type
#[derive(Debug)]
pub struct MapAccess<'a, R> {
    de: &'a mut Deserializer<R>,
    _size: usize,
    count: usize,
}

impl<'a, R> MapAccess<'a, R> {
    pub(crate) fn new(de: &'a mut Deserializer<R>, size: usize, count: usize) -> Self {
        Self {
            de,
            _size: size,
            count,
        }
    }
}

impl<R> AsMut<Deserializer<R>> for MapAccess<'_, R> {
    fn as_mut(&mut self) -> &mut Deserializer<R> {
        self.de
    }
}

impl<'de, R: Read<'de>> de::MapAccess<'de> for MapAccess<'_, R> {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
    where
        K: de::DeserializeSeed<'de>,
    {
        match self.count {
            0 => Ok(None),
            _ => {
                self.count -= 1;
                seed.deserialize(self.as_mut()).map(Some)
            }
        }
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
    where
        V: de::DeserializeSeed<'de>,
    {
        self.count -= 1;
        seed.deserialize(self.as_mut())
    }

    fn next_entry_seed<K, V>(
        &mut self,
        kseed: K,
        vseed: V,
    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>
    where
        K: de::DeserializeSeed<'de>,
        V: de::DeserializeSeed<'de>,
    {
        match self.count {
            0 => Ok(None),
            _ => {
                // AMQP map count includes both key and value
                self.count -= 2;
                let key = kseed.deserialize(self.as_mut())?;
                let val = vseed.deserialize(self.as_mut())?;
                Ok(Some((key, val)))
            }
        }
    }
}

/// Accessor for enum variant
#[derive(Debug)]
pub struct VariantAccess<'a, R> {
    de: &'a mut Deserializer<R>,
}

impl<'a, R> VariantAccess<'a, R> {
    pub(crate) fn new(de: &'a mut Deserializer<R>) -> Self {
        Self { de }
    }
}

impl<R> AsMut<Deserializer<R>> for VariantAccess<'_, R> {
    fn as_mut(&mut self) -> &mut Deserializer<R> {
        self.de
    }
}

impl<'de, R: Read<'de>> de::EnumAccess<'de> for VariantAccess<'_, R> {
    type Error = Error;
    type Variant = Self;

    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
    where
        V: de::DeserializeSeed<'de>,
    {
        let val = seed.deserialize(self.as_mut())?;
        Ok((val, self))
    }
}

impl<'de, R: Read<'de>> de::VariantAccess<'de> for VariantAccess<'_, R> {
    type Error = Error;

    fn unit_variant(self) -> Result<(), Self::Error> {
        Ok(())
    }

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

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

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

/// A special visitor access to the `Described` type
#[derive(Debug)]
pub struct DescribedAccess<'a, R> {
    de: &'a mut Deserializer<R>,
    counter: u32,
    field_count: u32,
}

impl<'a, 'de, R: Read<'de>> DescribedAccess<'a, R> {
    /// There will be at least one descriptor, and the length of the
    /// remaining items will be determined from the bytes
    pub(crate) fn list(de: &'a mut Deserializer<R>) -> Self {
        Self {
            de,
            field_count: 1,
            counter: 0,
        }
    }

    pub(crate) fn basic(de: &'a mut Deserializer<R>, field_count: u32) -> Self {
        Self {
            de,
            field_count,
            counter: 0,
        }
    }

    pub(crate) fn map(de: &'a mut Deserializer<R>) -> Self {
        Self {
            de,
            field_count: 1,
            counter: 0,
        }
    }

    pub(crate) fn consume_list_header(&mut self) -> Result<u32, Error> {
        // consume the list headers if
        match self
            .as_mut()
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??
        {
            EncodingCodes::List0 => Ok(0),
            EncodingCodes::List8 => {
                let _size = self
                    .as_mut()
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting size"))?;
                let count = self
                    .as_mut()
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting count"))?;
                Ok(count as u32)
            }
            EncodingCodes::List32 => {
                let bytes = self.as_mut().reader.read_const_bytes()?;
                let _size = u32::from_be_bytes(bytes);
                let bytes = self.as_mut().reader.read_const_bytes()?;
                let count = u32::from_be_bytes(bytes);
                Ok(count)
            }
            _ => Err(de::Error::custom("Invalid format code. Expecting a list")),
        }
    }

    pub(crate) fn consume_map_header(&mut self) -> Result<u32, Error> {
        // consume the list headers if
        match self
            .as_mut()
            .get_elem_code_or_read_format_code()
            .ok_or_else(|| Error::unexpected_eof("Expecting format code"))??
        {
            EncodingCodes::Map8 => {
                let _size = self
                    .as_mut()
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting size"))?;
                let count = self
                    .as_mut()
                    .reader
                    .next()?
                    .ok_or_else(|| Error::unexpected_eof("Expecting count"))?;
                Ok(count as u32)
            }
            EncodingCodes::Map32 => {
                let bytes = self.as_mut().reader.read_const_bytes()?;
                let _size = u32::from_be_bytes(bytes);
                let bytes = self.as_mut().reader.read_const_bytes()?;
                let count = u32::from_be_bytes(bytes);
                Ok(count)
            }
            _ => Err(de::Error::custom("Invalid format code. Expecting a list")),
        }
    }
}

impl<R> AsMut<Deserializer<R>> for DescribedAccess<'_, R> {
    fn as_mut(&mut self) -> &mut Deserializer<R> {
        self.de
    }
}

impl<'de, R: Read<'de>> de::SeqAccess<'de> for DescribedAccess<'_, R> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
    where
        T: de::DeserializeSeed<'de>,
    {
        if self.counter >= self.field_count {
            return Ok(None);
        }
        let byte = match self.de.reader.peek() {
            Some(b) => b,
            None => return Ok(None),
        };
        let code = byte.try_into()?;
        let result = match code {
            EncodingCodes::DescribedType => {
                let result = seed.deserialize(self.as_mut()).map(Some);
                // The list header should only be consume once for each list
                // The sublist will create new DescribedAccess and thus take care of their own
                // list headers
                if self.counter == 0 {
                    if let StructEncoding::DescribedList = self.de.struct_encoding {
                        self.field_count += self.consume_list_header()?;
                    }
                }
                result
            }
            _ => seed.deserialize(self.as_mut()).map(Some),
        };

        self.counter += 1;

        result
    }
}

impl<'de, R: Read<'de>> de::MapAccess<'de> for DescribedAccess<'_, R> {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
    where
        K: de::DeserializeSeed<'de>,
    {
        // Descriptor will only be deserialized as a key
        if self.counter >= self.field_count {
            return Ok(None);
        }
        let byte = match self.de.reader.peek() {
            Some(b) => b,
            None => return Ok(None),
        };
        let code = byte.try_into()?;
        let result = match code {
            EncodingCodes::Null => {
                let _ = self.de.reader.next(); // consume the Null byte
                Ok(None)
            }
            EncodingCodes::DescribedType => {
                self.de.enum_type = EnumType::Descriptor;
                let result = seed.deserialize(self.as_mut()).map(Some);
                if self.counter == 0 {
                    if let StructEncoding::DescribedMap = self.de.struct_encoding {
                        self.field_count += self.consume_map_header()?;
                    }
                }
                result
            }
            _ => seed.deserialize(self.as_mut()).map(Some),
        };

        self.counter += 1;

        result
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
    where
        V: de::DeserializeSeed<'de>,
    {
        if self.counter >= self.field_count {
            return Err(de::Error::custom("Invalid length. Expecting value"));
        }
        self.counter += 1;
        seed.deserialize(self.as_mut())
    }

    fn next_entry_seed<K, V>(
        &mut self,
        kseed: K,
        vseed: V,
    ) -> Result<Option<(K::Value, V::Value)>, Self::Error>
    where
        K: de::DeserializeSeed<'de>,
        V: de::DeserializeSeed<'de>,
    {
        if self.counter >= self.field_count {
            return Ok(None);
        }
        let byte = match self.de.reader.peek() {
            Some(b) => b,
            None => return Ok(None),
        };
        let code = byte.try_into()?;

        match code {
            EncodingCodes::Null => {
                let _ = self.de.reader.next(); // consume the Null byte
                Ok(None)
            }
            _ => {
                let key = kseed.deserialize(self.as_mut())?;
                let value = vseed.deserialize(self.as_mut())?;
                Ok(Some((key, value)))
            }
        }
    }
}

#[cfg(test)]
mod tests {
    use serde::{de::DeserializeOwned, Deserialize};

    use crate::format_code::EncodingCodes;

    use super::{from_reader, from_slice};

    fn assert_eq_from_reader_vs_expected<T>(buf: &[u8], expected: T)
    where
        T: DeserializeOwned + std::fmt::Debug + PartialEq,
    {
        let deserialized: T = from_reader(buf).unwrap();
        assert_eq!(deserialized, expected);
    }

    fn assert_eq_from_slice_vs_expected<'de, T>(buf: &'de [u8], expected: T)
    where
        T: Deserialize<'de> + std::fmt::Debug + PartialEq,
    {
        let deserialized: T = from_slice(buf).unwrap();
        assert_eq!(deserialized, expected)
    }

    #[test]
    fn test_deserialize_bool() {
        let buf = &[EncodingCodes::BooleanFalse as u8];
        let expected = false;
        assert_eq_from_reader_vs_expected(buf, expected);

        let buf = &[EncodingCodes::BooleanTrue as u8];
        let expected = true;
        assert_eq_from_reader_vs_expected(buf, expected);

        let buf = &[EncodingCodes::Boolean as u8, 1];
        let expected = true;
        assert_eq_from_reader_vs_expected(buf, expected);

        let buf = &[EncodingCodes::Boolean as u8, 0];
        let expected = false;
        assert_eq_from_reader_vs_expected(buf, expected);
    }

    #[test]
    fn test_deserialize_i8() {
        let buf = &[EncodingCodes::Byte as u8, 7i8 as u8];
        let expected = 7i8;
        assert_eq_from_reader_vs_expected(buf, expected);
    }

    #[test]
    fn test_deserialize_i16() {
        let mut buf = vec![EncodingCodes::Short as u8];
        buf.append(&mut 307i16.to_be_bytes().to_vec());
        let expected = 307i16;
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_i32() {
        let expected = -1i32;
        let buf = crate::to_vec(&expected).unwrap();
        println!("{:?}", buf);
        let deserialized: i32 = from_slice(&buf).unwrap();
        assert_eq!(expected, deserialized);

        let buf = &[EncodingCodes::SmallInt as u8, 7i32 as u8];
        let expected = 7i32;
        assert_eq_from_reader_vs_expected(buf, expected);
    }

    #[test]
    fn test_deserialize_i64() {
        let expected = -1i64;
        let buf = crate::to_vec(&expected).unwrap();
        let deserialized: i64 = from_slice(&buf).unwrap();
        assert_eq!(expected, deserialized);

        let buf = &[EncodingCodes::SmallLong as u8, 7i64 as u8];
        let expected = 7i64;
        assert_eq_from_reader_vs_expected(buf, expected);
    }

    #[test]
    fn test_deserialize_u8() {
        let buf = &[EncodingCodes::Ubyte as u8, 5u8];
        let expected = 5u8;
        assert_eq_from_reader_vs_expected(buf, expected);
    }

    #[test]
    fn test_deserialize_u16() {
        let mut buf = vec![EncodingCodes::Ushort as u8];
        buf.append(&mut 300u16.to_be_bytes().to_vec());
        let expected = 300u16;
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_u32() {
        let buf = &[EncodingCodes::Uint0 as u8];
        let expected = 0u32;
        assert_eq_from_reader_vs_expected(buf, expected);

        let buf = &[EncodingCodes::SmallUint as u8, 5u8];
        let expected = 5u32;
        assert_eq_from_reader_vs_expected(buf, expected);
    }

    #[test]
    fn test_deserialize_u64() {
        let buf = &[EncodingCodes::Ulong0 as u8];
        let expected = 0u64;
        assert_eq_from_reader_vs_expected(buf, expected);

        let buf = &[EncodingCodes::SmallUlong as u8, 5u8];
        let expected = 5u64;
        assert_eq_from_reader_vs_expected(buf, expected);
    }

    const SMALL_STRING_VALUE: &str = "Small String";
    const LARGE_STRING_VALUE: &str = r#"Large String: 
        "The quick brown fox jumps over the lazy dog. 
        "The quick brown fox jumps over the lazy dog. 
        "The quick brown fox jumps over the lazy dog. 
        "The quick brown fox jumps over the lazy dog. 
        "The quick brown fox jumps over the lazy dog. 
        "The quick brown fox jumps over the lazy dog. 
        "The quick brown fox jumps over the lazy dog. 
        "The quick brown fox jumps over the lazy dog."#;

    #[test]
    fn test_deserialize_str() {
        // str8
        let buf = [
            161u8, 12, 83, 109, 97, 108, 108, 32, 83, 116, 114, 105, 110, 103,
        ];
        let expected = SMALL_STRING_VALUE;
        assert_eq_from_slice_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_string() {
        // str8
        let buf = &[
            161u8, 12, 83, 109, 97, 108, 108, 32, 83, 116, 114, 105, 110, 103,
        ];
        let expected = SMALL_STRING_VALUE.to_string();
        assert_eq_from_reader_vs_expected(buf, expected);

        // str32
        let expected = LARGE_STRING_VALUE.to_string();
        let buf = crate::ser::to_vec(&expected).unwrap();
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_bytes() {
        use serde_bytes::ByteBuf;

        let buf = [EncodingCodes::Vbin8 as u8, 4, 1, 2, 3, 4];
        let expected = ByteBuf::from(vec![1u8, 2, 3, 4]);
        assert_eq_from_slice_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_decimal32() {
        use crate::primitives::Dec32;
        use crate::ser::to_vec;

        let expected = Dec32::from([1, 2, 3, 4]);
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_slice_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_decimal() {
        use crate::primitives::{Dec128, Dec32, Dec64};
        use crate::ser::to_vec;

        let expected = Dec32::from([1, 2, 3, 4]);
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_slice_vs_expected(&buf, expected);

        let expected = Dec64::from([1, 2, 3, 4, 5, 6, 7, 8]);
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_slice_vs_expected(&buf, expected);

        let expected = Dec128::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_slice_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_uuid() {
        use crate::primitives::Uuid;
        use crate::ser::to_vec;

        let expected = Uuid::from([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]);
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_slice_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_timestamp() {
        use crate::primitives::Timestamp;
        use crate::ser::to_vec;

        let expected = Timestamp::from(0);
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_symbol() {
        use crate::primitives::Symbol;
        let buf = &[0xa3_u8, 0x04, 0x61, 0x6d, 0x71, 0x70];
        let expected = Symbol::from("amqp");
        assert_eq_from_reader_vs_expected(buf, expected);
    }

    /// Helper function to test deserialization of en empty array
    ///
    /// The spec isn't really clear on how an empty array should be serialized.
    /// So we'll try to cover all possible cases. Future test cases should be added here
    fn test_deserialize_empty_array_inner<T>()
    where
        for<'de> T: Deserialize<'de> + std::fmt::Debug + PartialEq + Clone,
    {
        use crate::primitives::Array;

        let expected: Array<T> = Array::from(vec![]);

        // Empty array8 with no type constructor
        let buf = [
            EncodingCodes::Array8 as u8,
            0x01, // length
            0x00, // count
                  // The type constructor could be missing if the array is empty
                  // This behavior is observed in amqpnetlite
        ];
        assert_eq_from_reader_vs_expected(&buf, expected.clone());

        // Empty array8 with a null type constructor
        let buf = [
            EncodingCodes::Array8 as u8,
            0x02, // length
            0x00, // count
            0x40, // null
        ];
        assert_eq_from_reader_vs_expected(&buf, expected.clone());

        // Empty array32 with no type constructor
        let buf = [
            EncodingCodes::Array32 as u8,
            0x00,
            0x00,
            0x00,
            0x04, // length
            0x00,
            0x00,
            0x00,
            0x00, // count
        ];
        assert_eq_from_reader_vs_expected(&buf, expected.clone());

        // Empty array32 with a null type constructor
        let buf = [
            EncodingCodes::Array32 as u8,
            0x00,
            0x00,
            0x00,
            0x05, // length
            0x00,
            0x00,
            0x00,
            0x00, // count
            0x40, // null
        ];
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_empty_array() {
        use crate::primitives::*;

        // Cover all primitive types

        // bool
        test_deserialize_empty_array_inner::<bool>();

        // signed int
        test_deserialize_empty_array_inner::<i8>();
        test_deserialize_empty_array_inner::<i16>();
        test_deserialize_empty_array_inner::<i32>();
        test_deserialize_empty_array_inner::<i64>();

        // unsigned int
        test_deserialize_empty_array_inner::<u8>();
        test_deserialize_empty_array_inner::<u16>();
        test_deserialize_empty_array_inner::<u32>();
        test_deserialize_empty_array_inner::<u64>();

        // float
        test_deserialize_empty_array_inner::<f32>();
        test_deserialize_empty_array_inner::<f64>();

        // decimal32, decimal64, decimal128
        test_deserialize_empty_array_inner::<Dec32>();
        test_deserialize_empty_array_inner::<Dec64>();
        test_deserialize_empty_array_inner::<Dec128>();

        // char
        test_deserialize_empty_array_inner::<char>();

        // timestamp
        test_deserialize_empty_array_inner::<Timestamp>();

        // uuid
        test_deserialize_empty_array_inner::<Uuid>();

        // binary
        test_deserialize_empty_array_inner::<Binary>();

        // string
        test_deserialize_empty_array_inner::<String>();

        // symbol
        test_deserialize_empty_array_inner::<Symbol>();

        // list
        test_deserialize_empty_array_inner::<List<i32>>();

        // map
        test_deserialize_empty_array_inner::<OrderedMap<i32, i32>>();

        // array
        test_deserialize_empty_array_inner::<Array<i32>>();
    }

    #[test]
    fn test_deserialize_array() {
        use crate::primitives::Array;
        use crate::ser::to_vec;

        let expected = Array::from(vec![1i32, 2, 3, 4]);
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_empty_list() {
        // List0
        let expected: Vec<i32> = vec![];
        let buf = vec![EncodingCodes::List0 as u8];
        assert_eq_from_reader_vs_expected(&buf, expected);

        // List0
        let expected: &[i32; 0] = &[]; // slice will be (de)serialized as List
        let buf = vec![EncodingCodes::List0 as u8];
        assert_eq_from_reader_vs_expected(&buf, *expected);

        // List8
        let expected: Vec<i32> = vec![];
        let buf = vec![
            EncodingCodes::List8 as u8,
            1, // size
            0, // count
        ];
        assert_eq_from_reader_vs_expected(&buf, expected);

        // List32
        let expected: Vec<i32> = vec![];
        let buf = vec![
            EncodingCodes::List32 as u8,
            0,
            0,
            0,
            4, // size
            0,
            0,
            0,
            0, // count
        ];
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_list() {
        // List0
        let expected: Vec<i32> = vec![];
        let buf = vec![EncodingCodes::List0 as u8];
        assert_eq_from_reader_vs_expected(&buf, expected);

        // List0
        let expected: &[i32; 0] = &[]; // slice will be (de)serialized as List
        let buf = vec![EncodingCodes::List0 as u8];
        assert_eq_from_reader_vs_expected(&buf, *expected);

        // List8
        let expected = vec![1i32, 2, 3, 4];
        let buf = vec![
            EncodingCodes::List8 as u8,
            1 + 4 * 2,
            4,
            EncodingCodes::SmallInt as u8,
            1,
            EncodingCodes::SmallInt as u8,
            2,
            EncodingCodes::SmallInt as u8,
            3,
            EncodingCodes::SmallInt as u8,
            4,
        ];
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_map() {
        use std::collections::BTreeMap;

        // Map should be considered ordered (here by its key)
        let buf = vec![
            EncodingCodes::Map8 as u8,
            1 + 4 * (3 + 2), // 1 for count, 4 kv pairs, 3 for "a", 2 for 1i32
            2 * 4,           // 4 kv pairs
            EncodingCodes::Str8 as u8,
            1,
            b'a', // fisrt key
            EncodingCodes::SmallInt as u8,
            1, // first value
            EncodingCodes::Str8 as u8,
            1,
            b'm',
            EncodingCodes::SmallInt as u8,
            2,
            EncodingCodes::Str8 as u8,
            1,
            b'p',
            EncodingCodes::SmallInt as u8,
            4,
            EncodingCodes::Str8 as u8,
            1,
            b'q',
            EncodingCodes::SmallInt as u8,
            3,
        ];
        let mut expected = BTreeMap::new();
        expected.insert("a".to_string(), 1i32);
        expected.insert("m".to_string(), 2);
        expected.insert("q".to_string(), 3);
        expected.insert("p".to_string(), 4);

        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[cfg(feature = "serde_amqp_derive")]
    #[test]
    fn test_deserialize_unit_struct_with_described_macro() {
        use crate as serde_amqp;
        use crate::macros::{DeserializeComposite, SerializeComposite};
        use crate::ser::to_vec;

        {
            #[derive(Debug, PartialEq, SerializeComposite, DeserializeComposite)]
            #[amqp_contract(code = "00:13", encoding = "list")]
            struct Foo;

            let foo = Foo;
            let buf = to_vec(&foo).unwrap();
            let foo2: Foo = from_slice(&buf).unwrap();
            assert_eq!(foo, foo2);
        }

        {
            #[derive(Debug, PartialEq, SerializeComposite, DeserializeComposite)]
            #[amqp_contract(code = "00:13", encoding = "list")]
            struct Foo();

            let foo = Foo();
            let buf = to_vec(&foo).unwrap();
            let foo2: Foo = from_slice(&buf).unwrap();
            assert_eq!(foo, foo2);
        }

        {
            #[derive(Debug, PartialEq, SerializeComposite, DeserializeComposite)]
            #[amqp_contract(code = "00:13", encoding = "list")]
            struct Foo {}

            let foo = Foo {};
            let buf = to_vec(&foo).unwrap();
            let foo2: Foo = from_slice(&buf).unwrap();
            assert_eq!(foo, foo2);
        }
    }

    #[cfg(feature = "serde_amqp_derive")]
    #[test]
    fn test_deserialize_tuple_struct_with_described_macro() {
        use crate as serde_amqp;
        use crate::macros::{DeserializeComposite, SerializeComposite};
        use crate::ser::to_vec;

        #[derive(Debug, PartialEq, SerializeComposite, DeserializeComposite)]
        #[amqp_contract(code = "00:13", encoding = "list")]
        struct Foo(bool, i32);

        let foo = Foo(true, 9);
        let buf = to_vec(&foo).unwrap();
        let foo2: Foo = from_slice(&buf).unwrap();
        assert_eq!(foo, foo2);
    }

    #[cfg(feature = "serde_amqp_derive")]
    #[test]
    fn test_deserialize_struct_with_described_macro() {
        use crate as serde_amqp;
        use crate::macros::{DeserializeComposite, SerializeComposite};
        use crate::ser::to_vec;

        #[derive(Debug, PartialEq, SerializeComposite, DeserializeComposite)]
        #[amqp_contract(code = "00:13", encoding = "list", rename_all = "kebab-case")]
        struct Foo {
            is_fool: bool,
            a: i32,
        }

        #[derive(Debug, PartialEq, SerializeComposite, DeserializeComposite)]
        #[amqp_contract(code = "00:09", encoding = "list", rename_all = "kebab-case")]
        struct Bar {
            is_fool: bool,
            a: i32,
        }

        let foo = Foo {
            is_fool: true,
            a: 9,
        };
        let buf = to_vec(&foo).unwrap();
        let foo2: Foo = from_slice(&buf).unwrap();
        assert_eq!(foo, foo2);

        let bar = Bar {
            is_fool: false,
            a: 13,
        };
        let buf = to_vec(&bar).unwrap();
        let bar2: Bar = from_slice(&buf).unwrap();
        assert_eq!(bar, bar2)
    }

    #[cfg(feature = "serde_amqp_derive")]
    #[test]
    fn test_deserialize_composite_with_optional_fields() {
        use crate as serde_amqp;
        use crate::macros::DeserializeComposite;

        #[derive(Debug, DeserializeComposite)]
        #[amqp_contract(code = "0x00:0x13", encoding = "list")]
        struct Foo {
            pub is_fool: Option<bool>,
            pub a: Option<i32>,
        }

        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List0 as u8,
        ];
        let foo: Foo = from_slice(&buf).unwrap();
        assert!(foo.is_fool.is_none());
        assert!(foo.a.is_none());

        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List8 as u8,
            2,
            1,
            EncodingCodes::BooleanTrue as u8,
        ];
        let foo: Foo = from_slice(&buf).unwrap();
        assert!(foo.is_fool.is_some());
        assert!(foo.a.is_none());

        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List8 as u8,
            4,
            2,
            EncodingCodes::BooleanTrue as u8,
            EncodingCodes::SmallInt as u8,
            1,
        ];
        let foo: Foo = from_slice(&buf).unwrap();
        assert!(foo.is_fool.is_some());
        assert!(foo.a.is_some());

        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List8 as u8,
            4,
            2,
            EncodingCodes::Null as u8,
            EncodingCodes::SmallInt as u8,
            1,
        ];
        let foo: Foo = from_slice(&buf).unwrap();
        assert!(foo.is_fool.is_none());
        assert!(foo.a.is_some());
    }

    #[cfg(feature = "serde_amqp_derive")]
    #[test]
    fn test_deserialize_composite_tuple_with_optional_fields() {
        use crate as serde_amqp;
        use crate::macros::DeserializeComposite;

        #[derive(Debug, DeserializeComposite)]
        #[amqp_contract(code = "0x00:0x13", encoding = "list")]
        struct Foo(Option<bool>, Option<i32>);

        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List0 as u8,
        ];
        let foo: Foo = from_slice(&buf).unwrap();
        assert!(foo.0.is_none());
        assert!(foo.1.is_none());

        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List8 as u8,
            2,
            1,
            EncodingCodes::BooleanTrue as u8,
        ];
        let foo: Foo = from_slice(&buf).unwrap();
        assert!(foo.0.is_some());
        assert!(foo.1.is_none());

        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List8 as u8,
            4,
            2,
            EncodingCodes::BooleanTrue as u8,
            EncodingCodes::SmallInt as u8,
            1,
        ];
        let foo: Foo = from_slice(&buf).unwrap();
        assert!(foo.0.is_some());
        assert!(foo.1.is_some());

        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List8 as u8,
            4,
            2,
            EncodingCodes::Null as u8,
            EncodingCodes::SmallInt as u8,
            1,
        ];
        let foo: Foo = from_slice(&buf).unwrap();
        assert!(foo.0.is_none());
        assert!(foo.1.is_some());

        #[derive(Debug, PartialEq, DeserializeComposite)]
        #[amqp_contract(code = "0x00:0x13", encoding = "list")]
        struct Bar {
            is_fool: Option<bool>,
            mandatory: u32,
            a: Option<i32>,
        }
        let bar = Bar {
            is_fool: None,
            mandatory: 0x13,
            a: None,
        };
        let buf = vec![
            EncodingCodes::DescribedType as u8,
            EncodingCodes::SmallUlong as u8,
            0x13,
            EncodingCodes::List8 as u8,
            4,
            2,
            EncodingCodes::Null as u8,
            EncodingCodes::SmallUint as u8,
            0x13,
        ];
        let bar2: Bar = from_slice(&buf).unwrap();
        assert_eq!(bar, bar2);
    }

    #[cfg(feature = "serde_amqp_derive")]
    #[test]
    fn test_deserialize_basic_wrapper() {
        use crate as serde_amqp;
        use crate::macros::{DeserializeComposite, SerializeComposite};
        use crate::primitives::Symbol;
        use crate::ser::to_vec;
        use std::collections::BTreeMap;

        #[derive(Debug, SerializeComposite, DeserializeComposite, PartialEq)]
        #[amqp_contract(code = "0x00:0x01", encoding = "basic")]
        struct Wrapper(BTreeMap<Symbol, i32>);

        #[derive(Debug, SerializeComposite, DeserializeComposite, PartialEq)]
        #[amqp_contract(code = "0x00:0x1", encoding = "basic")]
        struct Wrapper2 {
            map: BTreeMap<Symbol, i32>,
        }

        let mut map = BTreeMap::new();
        map.insert(Symbol::from("a"), 1);
        map.insert(Symbol::from("b"), 2);
        let wrapper = Wrapper(map.clone());
        let buf = to_vec(&wrapper).unwrap();
        let wrapper1: Wrapper = from_slice(&buf).unwrap();
        assert_eq!(wrapper, wrapper1);

        let wrapper2 = Wrapper2 { map };
        let buf = to_vec(&wrapper2).unwrap();
        let wrapper3: Wrapper2 = from_slice(&buf).unwrap();
        assert_eq!(wrapper2, wrapper3);
    }

    #[test]
    fn test_deserialize_nondescribed_struct() {
        use crate::ser::to_vec;
        use serde::{Deserialize, Serialize};

        #[derive(Serialize, Deserialize, Debug, PartialEq)]
        struct Foo {
            bar: u32,
            is_fool: bool,
        }

        let expected = Foo {
            bar: 13,
            is_fool: true,
        };
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_unit_variant() {
        use serde::{Deserialize, Serialize};

        use crate::ser::to_vec;

        #[derive(Debug, Serialize, Deserialize, PartialEq)]
        enum Foo {
            A,
            B,
            C,
        }

        let foo = Foo::B;
        let buf = to_vec(&foo).unwrap();
        assert_eq_from_slice_vs_expected(&buf, foo);
    }

    #[test]
    fn test_deserialize_newtype_variant() {
        use serde::{Deserialize, Serialize};

        use crate::ser::to_vec;

        #[derive(Debug, Serialize, Deserialize, PartialEq)]
        enum Foo {
            A(String),
            B(u64),
        }

        let foo = Foo::B(13);
        let buf = to_vec(&foo).unwrap();
        assert_eq_from_slice_vs_expected(&buf, foo);
    }

    #[test]
    fn test_deserialize_tuple_variant() {
        use serde::{Deserialize, Serialize};

        use crate::ser::to_vec;

        #[derive(Debug, Serialize, Deserialize, PartialEq)]
        enum Foo {
            A(u32, bool),
            B(i32, String),
        }
        let expected = Foo::B(13, "amqp".to_string());
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    #[test]
    fn test_deserialize_struct_variant() {
        use serde::{Deserialize, Serialize};

        use crate::ser::to_vec;

        #[derive(Debug, Serialize, Deserialize, PartialEq)]
        enum Foo {
            A { num: u32, is_a: bool },
            B { signed_num: i32, amqp: String },
        }
        let expected = Foo::A {
            num: 13,
            is_a: true,
        };
        let buf = to_vec(&expected).unwrap();
        assert_eq_from_reader_vs_expected(&buf, expected);
    }

    // Regression tests for the unauthenticated DoS where an `array8` /
    // `array32` declares a count that vastly exceeds the encoded body
    // length. With a zero-width element format code (e.g. `null`/
    // `boolean-true`) the loop body consumes no bytes per iteration, so
    // without an upper bound a single 39-byte frame can drive the decoder
    // to iterate or allocate 2^31 times.

    #[test]
    fn array32_with_oversized_count_is_rejected() {
        use crate::error::Error;

        // The exact malicious tail from the original report: an `array32`
        // claiming 0x7FFFFFFF elements with a single-byte element format
        // code (Sym8) and a body size of only 9 bytes.
        let buf: &[u8] = &[0xf0, 0x00, 0x00, 0x00, 0x09, 0x7f, 0xff, 0xff, 0xff, 0xa3];

        let start = std::time::Instant::now();
        let result: Result<Vec<i32>, _> = from_slice(buf);
        let elapsed = start.elapsed();

        assert!(matches!(result, Err(Error::InvalidValue)));
        // A regression here would loop ~2^31 times; a sound implementation
        // returns immediately. Allow generous slack for slow CI machines.
        assert!(
            elapsed < std::time::Duration::from_secs(1),
            "rejection took too long: {:?}",
            elapsed
        );
    }

    #[test]
    fn array32_count_exceeding_len_is_rejected() {
        use crate::error::Error;

        // `array32` with a small count (10) of `null` (0x40) elements,
        // but a body size that only covers the count + format code
        // header (5 bytes). Without a `count <= len` check, each null
        // iteration would consume zero bytes and the loop would still
        // run 10 times against a 5-byte body — small here, but the same
        // shape scales up to the DoS pattern.
        let buf: &[u8] = &[0xf0, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0a, 0x40];

        let result: Result<Vec<()>, _> = from_slice(buf);
        assert!(matches!(result, Err(Error::InvalidValue)));
    }

    #[test]
    fn array32_at_max_count_succeeds() {
        use super::MAX_ARRAY_COUNT;

        // Round-trip an array whose count sits exactly on the cap.
        // Each element is a `ubyte` (1 byte body), so the total
        // body size is 4 (count) + 1 (elem format code) + COUNT.
        const COUNT: usize = MAX_ARRAY_COUNT;
        let body_size = 4 + 1 + COUNT;
        let mut buf = Vec::with_capacity(5 + body_size);
        buf.push(0xf0); // Array32
        buf.extend_from_slice(&(body_size as u32).to_be_bytes());
        buf.extend_from_slice(&(COUNT as u32).to_be_bytes());
        buf.push(0x50); // Ubyte format code
        buf.extend(std::iter::repeat_n(0u8, COUNT));

        let result: Vec<u8> = from_slice(&buf).unwrap();
        assert_eq!(result.len(), COUNT);
    }

    #[test]
    fn array8_with_oversized_count_is_rejected() {
        use crate::error::Error;

        // `array8` declaring 10 `null` elements with a body length of
        // only 2 bytes (count + format code, no element bodies). Same
        // shape as the array32 case but with single-byte fields.
        let buf: &[u8] = &[0xe0, 0x02, 0x0a, 0x40];

        let result: Result<Vec<()>, _> = from_slice(buf);
        assert!(matches!(result, Err(Error::InvalidValue)));
    }
}