use std::fmt::Formatter;

use serde::Deserialize;
use serde::Deserializer;
use serde::de::DeserializeSeed;
use serde::de::EnumAccess;
use serde::de::MapAccess;
use serde::de::SeqAccess;
use serde::de::VariantAccess;
use serde::de::Visitor;

/// Something that may be of the kind of `T`.
///
/// If a value doesn't have the kind of `T`, this will *discard* the value and
/// provide an `MayBe::IsNot`. Nevertheless, if the value does have the kind of
/// `T` but cannot be deserialized by `T`, this will also fail to deserialize,
/// making this wrapper "shallow".
///
/// For example, `struct`s have the same kind as a JSON object, `{}`, If the
/// contents of said JSON object don't match what the `struct` is expecting,
/// like if the `struct Foo { bar: u32 }` is being matched, as `MayBe<Foo>`,
/// against `{"bar": ""}`, then that is an error. However, matching the same
/// `MayBe<Foo>` against a JSON array, `[]` would not lead to an error, but
/// to an `MayBe::IsNot`.
///
/// Can only be used with self-describing formats, like JSON.
#[derive(Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub enum MayBe<T> {
    Is(T),
    IsNot,
}

// FIXME decide on Default
// This enum is analogous to Result, *not* Option.
//
//impl<T> Default for MayBe<T> {
//    fn default() -> Self {
//        MayBe::IsNot
//    }
//}
//impl<T: Default> Default for MayBe<T> {
//    fn default() -> Self {
//        MayBe::Is(T::default())
//    }
//}

impl<T> MayBe<T> {
    /// Returns whether the `MayBe` contains a `T`.
    pub fn is(&self) -> bool {
        matches!(self, MayBe::Is(_))
    }

    /// Returns whether the `MayBe` does not contain a `T`.
    pub fn is_not(&self) -> bool {
        !self.is()
    }

    /// Converts this `MayBe<T>` into an `Option<T>`.
    pub fn into_opt(self) -> Option<T> {
        self.into()
    }

    /// Converts this `&MayBe<T>` into an `Option<&T>`.
    pub fn as_opt(&self) -> Option<&T> {
        match self {
            MayBe::Is(t) => Some(t),
            MayBe::IsNot => None,
        }
    }

    /// Converts this `&mut MayBe<T>` into an `Option<&mut T>`.
    pub fn as_mut_opt(&mut self) -> Option<&mut T> {
        match self {
            MayBe::Is(t) => Some(t),
            MayBe::IsNot => None,
        }
    }
}

impl<T: Clone> Clone for MayBe<T> {
    fn clone(&self) -> Self {
        match self {
            MayBe::Is(t) => MayBe::Is(t.clone()),
            MayBe::IsNot => MayBe::IsNot,
        }
    }

    fn clone_from(&mut self, source: &Self) {
        match (self, source) {
            (MayBe::Is(a), MayBe::Is(b)) => a.clone_from(b),
            (MayBe::IsNot, MayBe::IsNot) => (),
            (a, b) => *a = b.clone(),
        }
    }
}

impl<T> From<MayBe<T>> for Option<T> {
    fn from(thing: MayBe<T>) -> Option<T> {
        match thing {
            MayBe::Is(t) => Some(t),
            MayBe::IsNot => None,
        }
    }
}

impl<T> From<Option<T>> for MayBe<T> {
    fn from(thing: Option<T>) -> MayBe<T> {
        match thing {
            Some(t) => MayBe::Is(t),
            None => MayBe::IsNot,
        }
    }
}

impl<T> From<T> for MayBe<T> {
    fn from(thing: T) -> MayBe<T> {
        MayBe::Is(thing)
    }
}

// actual deserialize

struct MayBeDer<'a, D>(&'a mut bool, D);

struct MayBeVis<'a, V>(&'a mut bool, V);

// acts as Deserializer, MapAccess, SeqAccess and EnumAccess, depending on T.
struct DeepDer<'a, T>(&'a mut bool, T);

#[derive(Deserialize)]
#[serde(untagged)]
enum MayBeHelper<T> {
    #[serde(deserialize_with="may_be")]
    #[serde(bound = "T: Deserialize<'de>")]
    Value(MayBe<T>),
}

fn may_be<'de, D: Deserializer<'de>, T: Deserialize<'de>>(
    d: D,
) -> Result<MayBe<T>, D::Error> {
    let mut depth: bool = false;
    match T::deserialize(MayBeDer(&mut depth, d)) {
        Ok(t) => Ok(MayBe::Is(t)),
        Err(_) if !depth => Ok(MayBe::IsNot),
        Err(e) => Err(e),
    }
}

impl<'de, T: Deserialize<'de>> Deserialize<'de> for MayBe<T> {
    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        MayBeHelper::<T>::deserialize(d).map(|MayBeHelper::Value(v): _| v)
    }
}

impl<'a, 'de: 'a, V: Visitor<'de>> Visitor<'de> for MayBeVis<'a, V> {
    type Value = V::Value;

    fn expecting(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
        let MayBeVis(_depth, inner) = self;
        inner.expecting(formatter)
    }

    fn visit_bool<E: serde::de::Error>(
        self,
        v: bool,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_bool(v)
    }

    fn visit_i8<E: serde::de::Error>(
        self,
        v: i8,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_i8(v)
    }

    fn visit_i16<E: serde::de::Error>(
        self,
        v: i16,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_i16(v)
    }

    fn visit_i32<E: serde::de::Error>(
        self,
        v: i32,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_i32(v)
    }

    fn visit_i64<E: serde::de::Error>(
        self,
        v: i64,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_i64(v)
    }

    fn visit_i128<E: serde::de::Error>(
        self,
        v: i128,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_i128(v)
    }

    fn visit_u8<E: serde::de::Error>(
        self,
        v: u8,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_u8(v)
    }

    fn visit_u16<E: serde::de::Error>(
        self,
        v: u16,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_u16(v)
    }

    fn visit_u32<E: serde::de::Error>(
        self,
        v: u32,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_u32(v)
    }

    fn visit_u64<E: serde::de::Error>(
        self,
        v: u64,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_u64(v)
    }

    fn visit_u128<E: serde::de::Error>(
        self,
        v: u128,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_u128(v)
    }

    fn visit_f32<E: serde::de::Error>(
        self,
        v: f32,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_f32(v)
    }

    fn visit_f64<E: serde::de::Error>(
        self,
        v: f64,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_f64(v)
    }

    fn visit_char<E: serde::de::Error>(
        self,
        v: char,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_char(v)
    }

    fn visit_str<E: serde::de::Error>(
        self,
        v: &str,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_str(v)
    }

    fn visit_borrowed_str<E: serde::de::Error>(
        self,
        v: &'de str,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_borrowed_str(v)
    }

    fn visit_string<E: serde::de::Error>(
        self,
        v: String,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_string(v)
    }

    fn visit_bytes<E: serde::de::Error>(
        self,
        v: &[u8],
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_bytes(v)
    }

    fn visit_borrowed_bytes<E: serde::de::Error>(
        self,
        v: &'de [u8],
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_borrowed_bytes(v)
    }

    fn visit_byte_buf<E: serde::de::Error>(
        self,
        v: Vec<u8>,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_byte_buf(v)
    }

    fn visit_none<E: serde::de::Error>(
        self,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_none()
    }

    fn visit_some<D: Deserializer<'de>>(
        self,
        deserializer: D,
    ) -> Result<Self::Value, D::Error> {
        let MayBeVis(depth, inner) = self;
        inner.visit_some(DeepDer(depth, deserializer))
    }

    fn visit_unit<E: serde::de::Error>(
        self,
    ) -> Result<Self::Value, E> {
        let MayBeVis(_depth, inner) = self;
        inner.visit_unit()
    }

    fn visit_newtype_struct<D: Deserializer<'de>>(
        self,
        deserializer: D,
    ) -> Result<Self::Value, D::Error> {
        let MayBeVis(depth, inner) = self;
        inner.visit_newtype_struct(DeepDer(depth, deserializer))
    }

    fn visit_seq<A: SeqAccess<'de>>(
        self,
        seq: A,
    ) -> Result<Self::Value, A::Error> {
        let MayBeVis(depth, inner) = self;
        inner.visit_seq(DeepDer(depth, seq))
    }

    fn visit_map<A: MapAccess<'de>>(
        self,
        map: A,
    ) -> Result<Self::Value, A::Error> {
        let MayBeVis(depth, inner) = self;
        inner.visit_map(DeepDer(depth, map))
    }

    fn visit_enum<A: EnumAccess<'de>>(
        self,
        data: A,
    ) -> Result<Self::Value, A::Error> {
        let MayBeVis(depth, inner) = self;
        inner.visit_enum(DeepDer(depth, data))
    }
}

impl<'a, 'de: 'a, D: Deserializer<'de>> Deserializer<'de> for MayBeDer<'a, D> {
    type Error = D::Error;

    fn deserialize_any<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_any(MayBeVis(depth, visitor))
    }

    fn deserialize_bool<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_bool(MayBeVis(depth, visitor))
    }

    fn deserialize_i8<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_i8(MayBeVis(depth, visitor))
    }

    fn deserialize_i16<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_i16(MayBeVis(depth, visitor))
    }

    fn deserialize_i32<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_i32(MayBeVis(depth, visitor))
    }

    fn deserialize_i64<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_i64(MayBeVis(depth, visitor))
    }

    fn deserialize_u8<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_u8(MayBeVis(depth, visitor))
    }

    fn deserialize_u16<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_u16(MayBeVis(depth, visitor))
    }

    fn deserialize_u32<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_u32(MayBeVis(depth, visitor))
    }

    fn deserialize_u64<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_u64(MayBeVis(depth, visitor))
    }

    fn deserialize_f32<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_f32(MayBeVis(depth, visitor))
    }

    fn deserialize_f64<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_f64(MayBeVis(depth, visitor))
    }

    fn deserialize_char<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_char(MayBeVis(depth, visitor))
    }

    fn deserialize_str<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_str(MayBeVis(depth, visitor))
    }

    fn deserialize_string<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_string(MayBeVis(depth, visitor))
    }

    fn deserialize_bytes<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_bytes(MayBeVis(depth, visitor))
    }

    fn deserialize_byte_buf<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_byte_buf(MayBeVis(depth, visitor))
    }

    fn deserialize_option<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_option(MayBeVis(depth, visitor))
    }

    fn deserialize_unit<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_unit(MayBeVis(depth, visitor))
    }

    fn deserialize_unit_struct<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_unit_struct(name, MayBeVis(depth, visitor))
    }

    fn deserialize_newtype_struct<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_newtype_struct(name, MayBeVis(depth, visitor))
    }

    fn deserialize_seq<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_seq(MayBeVis(depth, visitor))
    }

    fn deserialize_tuple<V: Visitor<'de>>(
        self, 
        len: usize, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_tuple(len, MayBeVis(depth, visitor))
    }

    fn deserialize_tuple_struct<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        len: usize, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_tuple_struct(name, len, MayBeVis(depth, visitor))
    }

    fn deserialize_map<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_map(MayBeVis(depth, visitor))
    }

    fn deserialize_struct<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        fields: &'static [&'static str], 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_struct(name, fields, MayBeVis(depth, visitor))
    }

    fn deserialize_enum<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        variants: &'static [&'static str], 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_enum(name, variants, MayBeVis(depth, visitor))
    }

    fn deserialize_identifier<V: Visitor<'de>>(
        self, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_identifier(MayBeVis(depth, visitor))
    }

    fn deserialize_ignored_any<V: Visitor<'de>>(
        self, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_ignored_any(MayBeVis(depth, visitor))
    }

    fn deserialize_i128<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_i128(MayBeVis(depth, visitor))
    }

    fn deserialize_u128<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let MayBeDer(depth, inner) = self;
        inner.deserialize_u128(MayBeVis(depth, visitor))
    }

    fn is_human_readable(&self) -> bool {
        let MayBeDer(_depth, inner) = self;
        inner.is_human_readable()
    }
}

impl<'a, 'de: 'a, A: VariantAccess<'de>> VariantAccess<'de> for DeepDer<'a, A> {
    type Error = A::Error;

    fn unit_variant(self) -> Result<(), Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.unit_variant()
    }

    fn newtype_variant_seed<T: DeserializeSeed<'de>>(
        self,
        seed: T,
    ) -> Result<T::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.newtype_variant_seed(seed)
    }

    fn tuple_variant<V: Visitor<'de>>(
        self, 
        len: usize, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.tuple_variant(len, visitor)
    }

    fn struct_variant<V: Visitor<'de>>(
        self, 
        fields: &'static [&'static str], 
        visitor: V
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.struct_variant(fields, visitor)
    }

    fn newtype_variant<T: Deserialize<'de>>(
        self,
    ) -> Result<T, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.newtype_variant()
    }
}

impl<'a, 'de: 'a, A: EnumAccess<'de>> EnumAccess<'de> for DeepDer<'a, A> {
    type Error = A::Error;

    type Variant = DeepDer<'a, A::Variant>;

    fn variant_seed<V: DeserializeSeed<'de>>(
        self, 
        seed: V,
    ) -> Result<(V::Value, Self::Variant), Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.variant_seed(seed).map(move |(a, b)| {
            (a, DeepDer(depth, b))
        })
    }

    fn variant<V: Deserialize<'de>>(
        self,
    ) -> Result<(V, Self::Variant), Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.variant().map(move |(a, b)| {
            (a, DeepDer(depth, b))
        })
    }
}

impl<'a, 'de: 'a, A: SeqAccess<'de>> SeqAccess<'de> for DeepDer<'a, A> {
    type Error = A::Error;

    fn next_element_seed<T: DeserializeSeed<'de>>(
        &mut self, 
        seed: T,
    ) -> Result<Option<T::Value>, Self::Error> {
        let DeepDer(ref mut depth, inner) = self;
        **depth = true;
        inner.next_element_seed(seed)
    }

    fn next_element<T: Deserialize<'de>>(
        &mut self, 
    ) -> Result<Option<T>, Self::Error> {
        let DeepDer(ref mut depth, inner) = self;
        **depth = true;
        inner.next_element()
    }

    fn size_hint(&self) -> Option<usize> {
        let DeepDer(_depth, inner) = self;
        inner.size_hint()
    }
}

impl<'a, 'de: 'a, A: MapAccess<'de>> MapAccess<'de> for DeepDer<'a, A> {
    type Error = A::Error;

    fn next_key_seed<K: DeserializeSeed<'de>>(
        &mut self, 
        seed: K,
    ) -> Result<Option<K::Value>, Self::Error> {
        let DeepDer(ref mut depth, inner) = self;
        **depth = true;
        inner.next_key_seed(seed)
    }

    fn next_value_seed<V: DeserializeSeed<'de>>(
        &mut self,
        seed: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(ref mut depth, inner) = self;
        **depth = true;
        inner.next_value_seed(seed)
    }

    fn next_entry_seed<K: DeserializeSeed<'de>, V: DeserializeSeed<'de>>(
        &mut self, 
        kseed: K, 
        vseed: V,
    ) -> Result<Option<(K::Value, V::Value)>, Self::Error> {
        let DeepDer(ref mut depth, inner) = self;
        **depth = true;
        inner.next_entry_seed(kseed, vseed)
    }

    fn next_key<K: Deserialize<'de>>(
        &mut self,
    ) -> Result<Option<K>, Self::Error> {
        let DeepDer(ref mut depth, inner) = self;
        **depth = true;
        inner.next_key()
    }

    fn next_value<V: Deserialize<'de>>(
        &mut self,
    ) -> Result<V, Self::Error> {
        let DeepDer(ref mut depth, inner) = self;
        **depth = true;
        inner.next_value()
    }

    fn next_entry<K: Deserialize<'de>, V: Deserialize<'de>>(
        &mut self,
    ) -> Result<Option<(K, V)>, Self::Error> {
        let DeepDer(ref mut depth, inner) = self;
        **depth = true;
        inner.next_entry()
    }

    fn size_hint(&self) -> Option<usize> {
        let DeepDer(_depth, inner) = self;
        inner.size_hint()
    }
}

impl<'a, 'de: 'a, D: Deserializer<'de>> Deserializer<'de> for DeepDer<'a, D> {
    type Error = D::Error;

    fn deserialize_any<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_any(visitor)
    }

    fn deserialize_bool<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_bool(visitor)
    }

    fn deserialize_i8<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_i8(visitor)
    }

    fn deserialize_i16<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_i16(visitor)
    }

    fn deserialize_i32<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_i32(visitor)
    }

    fn deserialize_i64<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_i64(visitor)
    }

    fn deserialize_u8<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_u8(visitor)
    }

    fn deserialize_u16<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_u16(visitor)
    }

    fn deserialize_u32<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_u32(visitor)
    }

    fn deserialize_u64<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_u64(visitor)
    }

    fn deserialize_f32<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_f32(visitor)
    }

    fn deserialize_f64<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_f64(visitor)
    }

    fn deserialize_char<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_char(visitor)
    }

    fn deserialize_str<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_str(visitor)
    }

    fn deserialize_string<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_string(visitor)
    }

    fn deserialize_bytes<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_bytes(visitor)
    }

    fn deserialize_byte_buf<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_byte_buf(visitor)
    }

    fn deserialize_option<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_option(visitor)
    }

    fn deserialize_unit<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_unit(visitor)
    }

    fn deserialize_unit_struct<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_unit_struct(name, visitor)
    }

    fn deserialize_newtype_struct<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_newtype_struct(name, visitor)
    }

    fn deserialize_seq<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_seq(visitor)
    }

    fn deserialize_tuple<V: Visitor<'de>>(
        self, 
        len: usize, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_tuple(len, visitor)
    }

    fn deserialize_tuple_struct<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        len: usize, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_tuple_struct(name, len, visitor)
    }

    fn deserialize_map<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_map(visitor)
    }

    fn deserialize_struct<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        fields: &'static [&'static str], 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_struct(name, fields, visitor)
    }

    fn deserialize_enum<V: Visitor<'de>>(
        self, 
        name: &'static str, 
        variants: &'static [&'static str], 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_enum(name, variants, visitor)
    }

    fn deserialize_identifier<V: Visitor<'de>>(
        self, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_identifier(visitor)
    }

    fn deserialize_ignored_any<V: Visitor<'de>>(
        self, 
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_ignored_any(visitor)
    }

    fn deserialize_i128<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_i128(visitor)
    }

    fn deserialize_u128<V: Visitor<'de>>(
        self,
        visitor: V,
    ) -> Result<V::Value, Self::Error> {
        let DeepDer(depth, inner) = self;
        *depth = true;
        inner.deserialize_u128(visitor)
    }

    fn is_human_readable(&self) -> bool {
        let DeepDer(_depth, inner) = self;
        inner.is_human_readable()
    }
}