use std::fmt;
use serde::de::{self, Deserializer, Visitor, SeqAccess, MapAccess};
use serde::Deserialize;

fn main() {}

struct Duration {
    secs: u64,
    nanos: u32,
}

impl<'de> de::Deserialize<'de> for Duration {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        // Comment out these lines and uncomment the manual impl of Deserialize
        // to make it work
        #[derive(Deserialize)]
        #[serde(field_identifier, rename_all = "lowercase")]
        enum Field { Secs, Nanos }

//        enum Field { Secs, Nanos };
//
//        impl<'de> Deserialize<'de> for Field {
//            fn deserialize<D>(deserializer: D) -> Result<Field, D::Error>
//            where
//                D: Deserializer<'de>,
//            {
//                struct FieldVisitor;
//
//                impl<'de> Visitor<'de> for FieldVisitor {
//                    type Value = Field;
//
//                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
//                        formatter.write_str("`secs` or `nanos`")
//                    }
//
//                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
//                    where
//                        E: de::Error,
//                    {
//                        match value {
//                            "secs" => Ok(Field::Secs),
//                            "nanos" => Ok(Field::Nanos),
//                            _ => Err(de::Error::unknown_field(value, FIELDS)),
//                        }
//                    }
//                }
//
//                deserializer.deserialize_identifier(FieldVisitor)
//            }
//        }

        struct DurationVisitor;

        impl<'de> Visitor<'de> for DurationVisitor {
            type Value = Duration;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("struct Duration")
            }

            fn visit_map<V>(self, mut map: V) -> Result<Duration, V::Error>
            where
                V: MapAccess<'de>,
            {
                let mut secs = None;
                let mut nanos = None;
                while let Some(key) = map.next_key()? {
                    match key {
                        Field::Secs => {
                            if secs.is_some() {
                                return Err(de::Error::duplicate_field("secs"));
                            }
                            secs = Some(map.next_value()?);
                        }
                        Field::Nanos => {
                            if nanos.is_some() {
                                return Err(de::Error::duplicate_field("nanos"));
                            }
                            nanos = Some(map.next_value()?);
                        }
                    }
                }
                let secs = secs.ok_or_else(|| de::Error::missing_field("secs"))?;
                let nanos = nanos.ok_or_else(|| de::Error::missing_field("nanos"))?;
                Ok(Duration { secs, nanos })
            }
        }

        const FIELDS: &'static [&'static str] = &["secs", "nanos"];
        deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
    }
}