ocpi-tariffs 0.20.0

use serde::de::{self, Deserialize, DeserializeSeed, Visitor};
use tracing::trace;

use std::fmt::{self, Display, Write as _};

use crate::{types::SpecFieldNames, UnexpectedFields};

const PATH_SEPARATOR: &str = ".";

/// Deserialize the given JSON (`&str`) into type T.
pub(crate) fn obj_from_json_str<'a, T>(
    json: &'a str,
) -> Result<(T, UnexpectedFields), serde_json::Error>
where
    T: Deserialize<'a> + SpecFieldNames,
{
    trace!(
        "Deserializing JSON into `{}` object\n{json}",
        std::any::type_name::<T>()
    );

    let deser = &mut serde_json::Deserializer::from_str(json);
    deserialize(deser, T::SPEC_FIELD_NAMES)
}

/// Use the given `Deserializer` to deserialize the given type while comparing each ignored field
/// to a list of fields defined in the spec for the given type.
///
/// If the field is not defined by the spec for the type, then the field name is stored
/// in a set for later review.
pub fn deserialize<'de, D, T>(
    deserializer: D,
    spec_fields: &'static [&'static str],
) -> Result<(T, UnexpectedFields), D::Error>
where
    D: de::Deserializer<'de>,
    T: Deserialize<'de>,
{
    // The path is written to this buffer to compare it with the `spec_fields` list.
    let mut path_buf = String::with_capacity(256);
    let mut unexpected_fields = UnexpectedFields::new();
    let value = T::deserialize(Deserializer::new(
        deserializer,
        spec_fields,
        &mut unexpected_fields,
        &mut path_buf,
    ))?;
    Ok((value, unexpected_fields))
}

/// Deserializer adapter that compares each ignored field to a list of spec fields
/// for the given type.
///
/// If the field is not defined by the spec for the type, then the field name is stored
/// in a set for later review.
pub struct Deserializer<'a, 'b, D> {
    de: D,
    state: State<'a, 'b>,
}

/// Common state stored by all deserializers.
///
/// Only the [`Deserizlizer`] actually uses the fields. The rest of the objects just act as a
/// pass-through.
struct State<'a, 'b> {
    spec_fields: &'static [&'static str],
    unexpected_fields: &'b mut UnexpectedFields,
    path_buf: &'b mut String,
    path: Path<'a>,
}

impl<'b, D> Deserializer<'_, 'b, D> {
    pub fn new(
        de: D,
        spec_fields: &'static [&'static str],
        unexpected_fields: &'b mut UnexpectedFields,
        path_buf: &'b mut String,
    ) -> Self {
        Deserializer {
            de,
            state: State {
                spec_fields,
                unexpected_fields,
                path_buf,
                path: Path::Root,
            },
        }
    }
}

/// Path to the current value in the input, like `dependencies.serde.typo1`.
///
/// We explicitly do not add Rust types such as structs and newtypes to the path as
/// this path is for use by the user. All the Rust types involved in deserializing
/// the CDR and tariffs are private to the crate.
#[derive(Clone)]
pub enum Path<'a> {
    Root,
    Seq { parent: &'a Path<'a>, index: usize },
    Map { parent: &'a Path<'a>, key: String },
}

impl Display for Path<'_> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
        struct Parent<'a>(&'a Path<'a>);

        impl Display for Parent<'_> {
            fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
                match *self.0 {
                    Path::Root => Ok(()),
                    ref path => write!(f, "{path}{PATH_SEPARATOR}"),
                }
            }
        }

        match *self {
            Path::Root => f.write_str(PATH_SEPARATOR),
            Path::Seq { parent, index } => write!(f, "{}{}", Parent(parent), index),
            Path::Map { parent, ref key } => write!(f, "{}{}", Parent(parent), key),
        }
    }
}

/// Plain old forwarding impl except for `deserialize_ignored_any` which compares the ignored field
/// with the `spec_fields` list.
impl<'de, D> de::Deserializer<'de> for Deserializer<'_, '_, D>
where
    D: de::Deserializer<'de>,
{
    type Error = D::Error;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_any(Wrap::new(visitor, self.state))
    }

    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_bool(Wrap::new(visitor, self.state))
    }

    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_u8(Wrap::new(visitor, self.state))
    }

    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_u16(Wrap::new(visitor, self.state))
    }

    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_u32(Wrap::new(visitor, self.state))
    }

    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_u64(Wrap::new(visitor, self.state))
    }

    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_i8(Wrap::new(visitor, self.state))
    }

    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_i16(Wrap::new(visitor, self.state))
    }

    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_i32(Wrap::new(visitor, self.state))
    }

    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_i64(Wrap::new(visitor, self.state))
    }

    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_f32(Wrap::new(visitor, self.state))
    }

    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_f64(Wrap::new(visitor, self.state))
    }

    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_char(Wrap::new(visitor, self.state))
    }

    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_str(Wrap::new(visitor, self.state))
    }

    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_string(Wrap::new(visitor, self.state))
    }

    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_bytes(Wrap::new(visitor, self.state))
    }

    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_byte_buf(Wrap::new(visitor, self.state))
    }

    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_option(Wrap::new(visitor, self.state))
    }

    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_unit(Wrap::new(visitor, self.state))
    }

    fn deserialize_unit_struct<V>(
        self,
        name: &'static str,
        visitor: V,
    ) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de
            .deserialize_unit_struct(name, Wrap::new(visitor, self.state))
    }

    fn deserialize_newtype_struct<V>(
        self,
        name: &'static str,
        visitor: V,
    ) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de
            .deserialize_newtype_struct(name, Wrap::new(visitor, self.state))
    }

    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_seq(Wrap::new(visitor, self.state))
    }

    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de
            .deserialize_tuple(len, Wrap::new(visitor, self.state))
    }

    fn deserialize_tuple_struct<V>(
        self,
        name: &'static str,
        len: usize,
        visitor: V,
    ) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de
            .deserialize_tuple_struct(name, len, Wrap::new(visitor, self.state))
    }

    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de.deserialize_map(Wrap::new(visitor, self.state))
    }

    fn deserialize_struct<V>(
        self,
        name: &'static str,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de
            .deserialize_struct(name, fields, Wrap::new(visitor, self.state))
    }

    fn deserialize_enum<V>(
        self,
        name: &'static str,
        variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de
            .deserialize_enum(name, variants, Wrap::new(visitor, self.state))
    }

    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        let Self {
            de,
            state:
                State {
                    spec_fields,
                    unexpected_fields,
                    path_buf,
                    path,
                },
        } = self;

        path_buf.clear();
        write!(path_buf, "{path}").map_err(de::Error::custom)?;
        let field_name = &**path_buf;

        if !spec_fields.contains(&field_name) {
            unexpected_fields.insert(field_name.to_string());
        }

        de.deserialize_ignored_any(visitor)
    }

    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, D::Error>
    where
        V: Visitor<'de>,
    {
        self.de
            .deserialize_identifier(Wrap::new(visitor, self.state))
    }

    /// We know that the format is JSON.
    fn is_human_readable(&self) -> bool {
        true
    }
}

/// Wrapper that attaches context to a `Visitor`, `SeqAccess`, `EnumAccess` or
/// `VariantAccess`.
struct Wrap<'a, 'b, X> {
    delegate: X,
    state: State<'a, 'b>,
}

impl<'a, 'b, X> Wrap<'a, 'b, X> {
    fn new(delegate: X, state: State<'a, 'b>) -> Self {
        Wrap { delegate, state }
    }
}

/// Forwarding impl to preserve context.
impl<'de, X> Visitor<'de> for Wrap<'_, '_, X>
where
    X: Visitor<'de>,
{
    type Value = X::Value;

    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.delegate.expecting(formatter)
    }

    fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_bool(v)
    }

    fn visit_i8<E>(self, v: i8) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_i8(v)
    }

    fn visit_i16<E>(self, v: i16) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_i16(v)
    }

    fn visit_i32<E>(self, v: i32) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_i32(v)
    }

    fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_i64(v)
    }

    fn visit_u8<E>(self, v: u8) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_u8(v)
    }

    fn visit_u16<E>(self, v: u16) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_u16(v)
    }

    fn visit_u32<E>(self, v: u32) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_u32(v)
    }

    fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_u64(v)
    }

    fn visit_f32<E>(self, v: f32) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_f32(v)
    }

    fn visit_f64<E>(self, v: f64) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_f64(v)
    }

    fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_char(v)
    }

    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_str(v)
    }

    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_borrowed_str(v)
    }

    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_string(v)
    }

    fn visit_unit<E>(self) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_unit()
    }

    fn visit_none<E>(self) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_none()
    }

    fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        self.delegate.visit_some(Deserializer {
            de: deserializer,
            state: self.state,
        })
    }

    fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        self.delegate.visit_newtype_struct(Deserializer {
            de: deserializer,
            state: self.state,
        })
    }

    fn visit_seq<V>(self, seq: V) -> Result<Self::Value, V::Error>
    where
        V: de::SeqAccess<'de>,
    {
        self.delegate.visit_seq(SeqAccess::new(seq, self.state))
    }

    fn visit_map<V>(self, map: V) -> Result<Self::Value, V::Error>
    where
        V: de::MapAccess<'de>,
    {
        self.delegate.visit_map(MapAccess::new(map, self.state))
    }

    fn visit_enum<V>(self, data: V) -> Result<Self::Value, V::Error>
    where
        V: de::EnumAccess<'de>,
    {
        self.delegate.visit_enum(Wrap::new(data, self.state))
    }

    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_bytes(v)
    }

    fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_borrowed_bytes(v)
    }

    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        self.delegate.visit_byte_buf(v)
    }
}

/// Forwarding impl to preserve context.
impl<'a, 'b, 'de, X> de::EnumAccess<'de> for Wrap<'a, 'b, X>
where
    X: de::EnumAccess<'de> + 'a,
{
    type Error = X::Error;
    type Variant = Wrap<'a, 'b, X::Variant>;

    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), X::Error>
    where
        V: DeserializeSeed<'de>,
    {
        let Self { delegate, state } = self;
        delegate
            .variant_seed(seed)
            .map(move |(v, vis)| (v, Wrap::new(vis, state)))
    }
}

/// Forwarding impl to preserve context.
impl<'de, X> de::VariantAccess<'de> for Wrap<'_, '_, X>
where
    X: de::VariantAccess<'de>,
{
    type Error = X::Error;

    fn unit_variant(self) -> Result<(), X::Error> {
        self.delegate.unit_variant()
    }

    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, X::Error>
    where
        T: DeserializeSeed<'de>,
    {
        let Self { delegate, state } = self;
        delegate.newtype_variant_seed(TrackedSeed::new(seed, state))
    }

    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        let Self { delegate, state } = self;
        delegate.tuple_variant(len, Wrap::new(visitor, state))
    }

    fn struct_variant<V>(
        self,
        fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        let Self { delegate, state } = self;
        delegate.struct_variant(fields, Wrap::new(visitor, state))
    }
}

/// Seed that saves the string into the given optional during `visit_str` and
/// `visit_string`.
struct CaptureKey<'a, X> {
    delegate: X,
    key: &'a mut Option<String>,
}

impl<'a, X> CaptureKey<'a, X> {
    fn new(delegate: X, key: &'a mut Option<String>) -> Self {
        CaptureKey { delegate, key }
    }
}

/// Forwarding impl.
impl<'de, X> DeserializeSeed<'de> for CaptureKey<'_, X>
where
    X: DeserializeSeed<'de>,
{
    type Value = X::Value;

    fn deserialize<D>(self, deserializer: D) -> Result<X::Value, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        self.delegate
            .deserialize(CaptureKey::new(deserializer, self.key))
    }
}

/// Forwarding impl.
impl<'de, X> de::Deserializer<'de> for CaptureKey<'_, X>
where
    X: de::Deserializer<'de>,
{
    type Error = X::Error;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        self.delegate
            .deserialize_any(CaptureKey::new(visitor, self.key))
    }

    fn deserialize_bool<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("bool is not a valid JSON key"))
    }

    fn deserialize_u8<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("u8 is not a valid JSON key"))
    }

    fn deserialize_u16<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("u16 is not a valid JSON key"))
    }

    fn deserialize_u32<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("u32 is not a valid JSON key"))
    }

    fn deserialize_u64<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("u64 is not a valid JSON key"))
    }

    fn deserialize_i8<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("i8 is not a valid JSON key"))
    }

    fn deserialize_i16<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("i16 is not a valid JSON key"))
    }

    fn deserialize_i32<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("i32 is not a valid JSON key"))
    }

    fn deserialize_i64<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("i64 is not a valid JSON key"))
    }

    fn deserialize_f32<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("f32 is not a valid JSON key"))
    }

    fn deserialize_f64<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("f64 is not a valid JSON key"))
    }

    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("char is not a valid JSON key"))
    }

    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        self.delegate
            .deserialize_str(CaptureKey::new(visitor, self.key))
    }

    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        self.delegate
            .deserialize_string(CaptureKey::new(visitor, self.key))
    }

    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("bytes is not a valid JSON key"))
    }

    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("buf is not a valid JSON key"))
    }

    fn deserialize_option<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("option is not a valid JSON key"))
    }

    fn deserialize_unit<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("unit is not a valid JSON key"))
    }

    fn deserialize_unit_struct<V>(
        self,
        _name: &'static str,
        _visitor: V,
    ) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("struct is not a valid JSON key"))
    }

    fn deserialize_newtype_struct<V>(
        self,
        _name: &'static str,
        _visitor: V,
    ) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("struct is not a valid JSON key"))
    }

    fn deserialize_seq<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("seq is not a valid JSON key"))
    }

    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("tuple is not a valid JSON key"))
    }

    fn deserialize_tuple_struct<V>(
        self,
        _name: &'static str,
        _len: usize,
        _visitor: V,
    ) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("struct is not a valid JSON key"))
    }

    fn deserialize_map<V>(self, _visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("map is not a valid JSON key"))
    }

    fn deserialize_struct<V>(
        self,
        _name: &'static str,
        _fields: &'static [&'static str],
        _visitor: V,
    ) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("struct is not a valid JSON key"))
    }

    fn deserialize_enum<V>(
        self,
        _name: &'static str,
        _variants: &'static [&'static str],
        _visitor: V,
    ) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        Err(de::Error::custom("enum is not a valid JSON key"))
    }

    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        self.delegate
            .deserialize_ignored_any(CaptureKey::new(visitor, self.key))
    }

    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, X::Error>
    where
        V: Visitor<'de>,
    {
        self.delegate
            .deserialize_identifier(CaptureKey::new(visitor, self.key))
    }

    /// We know that the format is JSON.
    fn is_human_readable(&self) -> bool {
        true
    }
}

/// Forwarding impl that also saves the value of integers and strings.
impl<'de, X> Visitor<'de> for CaptureKey<'_, X>
where
    X: Visitor<'de>,
{
    type Value = X::Value;

    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.delegate.expecting(formatter)
    }

    /// The keys of a JSON object should always be a `&str`.
    ///
    /// The `CDR` and tariff types are private and the deserialization is performed privately too.
    /// Therefore the whole deserializetion routine is under our control.
    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        *self.key = Some(v.to_owned());
        self.delegate.visit_str(v)
    }

    /// The keys of a JSON object should always be a `&str`.
    ///
    /// The `CDR` and tariff types are private and the deserialization is performed privately too.
    /// Therefore the whole deserializetion routine is under our control.
    fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
    where
        E: de::Error,
    {
        *self.key = Some(v.to_owned());
        self.delegate.visit_borrowed_str(v)
    }
}

impl<'de, X> de::EnumAccess<'de> for CaptureKey<'_, X>
where
    X: de::EnumAccess<'de>,
{
    type Error = X::Error;
    type Variant = X::Variant;

    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), X::Error>
    where
        V: DeserializeSeed<'de>,
    {
        self.delegate.variant_seed(CaptureKey::new(seed, self.key))
    }
}

/// Seed used for map values, sequence elements and newtype variants to track
/// their path.
struct TrackedSeed<'a, 'b, X> {
    seed: X,
    state: State<'a, 'b>,
}

impl<'a, 'b, X> TrackedSeed<'a, 'b, X> {
    fn new(seed: X, state: State<'a, 'b>) -> Self {
        TrackedSeed { seed, state }
    }
}

impl<'de, X> DeserializeSeed<'de> for TrackedSeed<'_, '_, X>
where
    X: DeserializeSeed<'de>,
{
    type Value = X::Value;

    fn deserialize<D>(self, deserializer: D) -> Result<X::Value, D::Error>
    where
        D: de::Deserializer<'de>,
    {
        self.seed.deserialize(Deserializer {
            de: deserializer,
            state: self.state,
        })
    }
}

/// Seq visitor that tracks the index of its elements.
struct SeqAccess<'a, 'b, X> {
    delegate: X,
    index: usize,
    state: State<'a, 'b>,
}

impl<'a, 'b, X> SeqAccess<'a, 'b, X> {
    fn new(delegate: X, state: State<'a, 'b>) -> Self {
        SeqAccess {
            delegate,
            index: 0,
            state,
        }
    }
}

/// Forwarding impl to preserve context.
impl<'de, X> de::SeqAccess<'de> for SeqAccess<'_, '_, X>
where
    X: de::SeqAccess<'de>,
{
    type Error = X::Error;

    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, X::Error>
    where
        T: DeserializeSeed<'de>,
    {
        let path = Path::Seq {
            parent: &self.state.path,
            index: self.index,
        };
        self.index += 1;
        let state = State {
            spec_fields: self.state.spec_fields,
            unexpected_fields: self.state.unexpected_fields,
            path_buf: self.state.path_buf,
            path,
        };
        self.delegate
            .next_element_seed(TrackedSeed::new(seed, state))
    }

    fn size_hint(&self) -> Option<usize> {
        self.delegate.size_hint()
    }
}

/// Map visitor that captures the string value of its keys and uses that to
/// track the path to its values.
struct MapAccess<'a, 'b, X> {
    delegate: X,
    key: Option<String>,
    state: State<'a, 'b>,
}

impl<'a, 'b, X> MapAccess<'a, 'b, X> {
    fn new(delegate: X, state: State<'a, 'b>) -> Self {
        MapAccess {
            delegate,
            key: None,
            state,
        }
    }

    fn key<E>(&mut self) -> Result<String, E>
    where
        E: de::Error,
    {
        self.key.take().ok_or_else(|| E::custom("non-string key"))
    }
}

impl<'de, X> de::MapAccess<'de> for MapAccess<'_, '_, X>
where
    X: de::MapAccess<'de>,
{
    type Error = X::Error;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, X::Error>
    where
        K: DeserializeSeed<'de>,
    {
        self.delegate
            .next_key_seed(CaptureKey::new(seed, &mut self.key))
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, X::Error>
    where
        V: DeserializeSeed<'de>,
    {
        let key = self.key()?;
        let path = Path::Map {
            parent: &self.state.path,
            key,
        };
        let state = State {
            spec_fields: self.state.spec_fields,
            unexpected_fields: self.state.unexpected_fields,
            path_buf: self.state.path_buf,
            path,
        };
        self.delegate.next_value_seed(TrackedSeed::new(seed, state))
    }

    fn size_hint(&self) -> Option<usize> {
        self.delegate.size_hint()
    }
}