use serde_core::de::IntoDeserializer;
use serde_spanned::Spanned;

use crate::de::DeString;
use crate::de::DeTable;
use crate::de::DeValue;
use crate::de::Error;
use crate::map::IntoIter;

pub(crate) struct TableDeserializer<'i> {
    span: core::ops::Range<usize>,
    items: DeTable<'i>,
}

impl<'i> TableDeserializer<'i> {
    pub(crate) fn new(items: DeTable<'i>, span: core::ops::Range<usize>) -> Self {
        Self { span, items }
    }
}

impl<'de> serde_core::Deserializer<'de> for TableDeserializer<'de> {
    type Error = Error;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
    where
        V: serde_core::de::Visitor<'de>,
    {
        visitor.visit_map(TableMapAccess::new(self))
    }

    // `None` is interpreted as a missing field so be sure to implement `Some`
    // as a present field.
    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Error>
    where
        V: serde_core::de::Visitor<'de>,
    {
        visitor.visit_some(self)
    }

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

    fn deserialize_struct<V>(
        self,
        name: &'static str,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Error>
    where
        V: serde_core::de::Visitor<'de>,
    {
        if serde_spanned::de::is_spanned(name) {
            let span = self.span.clone();
            return visitor.visit_map(super::SpannedDeserializer::new(self, span));
        }

        self.deserialize_any(visitor)
    }

    // Called when the type to deserialize is an enum, as opposed to a field in the type.
    fn deserialize_enum<V>(
        self,
        _name: &'static str,
        _variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value, Error>
    where
        V: serde_core::de::Visitor<'de>,
    {
        if self.items.is_empty() {
            Err(Error::custom(
                "wanted exactly 1 element, found 0 elements",
                Some(self.span),
            ))
        } else if self.items.len() != 1 {
            Err(Error::custom(
                "wanted exactly 1 element, more than 1 element",
                Some(self.span),
            ))
        } else {
            visitor.visit_enum(TableMapAccess::new(self))
        }
    }

    serde_core::forward_to_deserialize_any! {
        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
        bytes byte_buf map unit
        ignored_any unit_struct tuple_struct tuple identifier
    }
}

impl<'de> IntoDeserializer<'de, Error> for TableDeserializer<'de> {
    type Deserializer = Self;

    fn into_deserializer(self) -> Self::Deserializer {
        self
    }
}

pub(crate) struct TableMapAccess<'i> {
    iter: IntoIter<Spanned<DeString<'i>>, Spanned<DeValue<'i>>>,
    span: core::ops::Range<usize>,
    value: Option<(Spanned<DeString<'i>>, Spanned<DeValue<'i>>)>,
}

impl<'i> TableMapAccess<'i> {
    pub(crate) fn new(input: TableDeserializer<'i>) -> Self {
        Self {
            iter: input.items.into_iter(),
            span: input.span,
            value: None,
        }
    }
}

impl<'de> serde_core::de::MapAccess<'de> for TableMapAccess<'de> {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
    where
        K: serde_core::de::DeserializeSeed<'de>,
    {
        match self.iter.next() {
            Some((k, v)) => {
                let key_span = k.span();
                let ret = seed
                    .deserialize(super::KeyDeserializer::new(
                        k.clone().into_inner(),
                        Some(key_span.clone()),
                    ))
                    .map(Some)
                    .map_err(|mut e: Self::Error| {
                        if e.span().is_none() {
                            e.set_span(Some(key_span));
                        }
                        e
                    });
                self.value = Some((k, v));
                ret
            }
            None => Ok(None),
        }
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
    where
        V: serde_core::de::DeserializeSeed<'de>,
    {
        match self.value.take() {
            Some((k, v)) => {
                let span = v.span();
                seed.deserialize(crate::de::ValueDeserializer::with_parts(
                    v.into_inner(),
                    span.clone(),
                ))
                .map_err(|mut e: Self::Error| {
                    if e.span().is_none() {
                        e.set_span(Some(span));
                    }
                    e.add_key(k.into_inner().into_owned());
                    e
                })
            }
            None => {
                panic!("no more values in next_value_seed, internal error in ValueDeserializer")
            }
        }
    }
}

impl<'de> serde_core::de::EnumAccess<'de> for TableMapAccess<'de> {
    type Error = Error;
    type Variant = super::TableEnumDeserializer<'de>;

    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
    where
        V: serde_core::de::DeserializeSeed<'de>,
    {
        let (key, value) = match self.iter.next() {
            Some(pair) => pair,
            None => {
                return Err(Error::custom(
                    "expected table with exactly 1 entry, found empty table",
                    Some(self.span),
                ));
            }
        };

        let key_span = key.span();
        let val = seed
            .deserialize(super::KeyDeserializer::new(
                key.into_inner(),
                Some(key_span.clone()),
            ))
            .map_err(|mut e: Self::Error| {
                if e.span().is_none() {
                    e.set_span(Some(key_span));
                }
                e
            })?;

        let value_span = value.span();
        let value = value.into_inner();
        let variant = super::TableEnumDeserializer::new(value, value_span);

        Ok((val, variant))
    }
}