use crate::value::{Value, AValue, Dictionary};
use crate::value::value::{Float, Double};
use crate::value::error::{Error, Result};
use num::traits::cast::ToPrimitive;
use serde::Deserialize;
use serde::de::{Visitor, SeqAccess, MapAccess, EnumAccess, VariantAccess, DeserializeSeed};
use std::convert::TryFrom;
use std::iter::Iterator;

pub struct Deserializer<'de> {
    input: &'de AValue,
}

pub fn from_value<'a, T>(v: &'a AValue) -> Result<T> where T: Deserialize<'a> {
    let mut de = Deserializer::from_value(v);
    let t = T::deserialize(&mut de)?;
    Ok(t)
}

impl<'de> Deserializer<'de> {
    pub fn from_value(v: &'de AValue) -> Self {
        Deserializer{ input: v }
    }
}

impl<'de, 'a> serde::de::Deserializer<'de> for &'a mut Deserializer<'de> {
    type Error = Error;

    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let v = self.input.value();
        match v {
            Value::Boolean(b) => visitor.visit_bool(*b),
            Value::Float(Float(f)) => visitor.visit_f32(*f),
            Value::Double(Double(d)) => visitor.visit_f64(*d),
            Value::SignedInteger(ref i) =>
                match i.to_i64() {
                    None => match i.to_u64() {
                        None => Err(Error::NumberTooLarge(i.clone())),
                        Some(n) => visitor.visit_u64(n),
                    }
                    Some(n) => visitor.visit_i64(n),
                }
            Value::String(ref s) => visitor.visit_str(&s),
            Value::ByteString(_) => self.deserialize_bytes(visitor),
            Value::Record(_) =>
                if v.is_simple_record("tuple", Some(0)) {
                    self.deserialize_unit(visitor)
                } else if v.is_simple_record("UnicodeScalar", Some(1)) {
                    self.deserialize_char(visitor)
                } else
                    if v.is_simple_record("None", Some(0)) ||
                    v.is_simple_record("Some", Some(1))
                {
                    self.deserialize_option(visitor)
                } else if v.is_simple_record("tuple", None) {
                    visitor.visit_seq(VecSeq::new(self, v.as_simple_record("tuple", None).unwrap()))
                } else {
                    Err(Error::Syntax)
                }
            Value::Sequence(ref v) => visitor.visit_seq(VecSeq::new(self, v)),
            Value::Dictionary(ref d) => visitor.visit_map(DictMap::new(self, d)),
            _ => Err(Error::Syntax),
        }
    }

    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_bool(self.input.value().as_boolean().ok_or(Error::Syntax)?)
    }

    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let i = self.input.value().as_signedinteger().ok_or(Error::Syntax)?;
        visitor.visit_i8(i.to_i8().ok_or(Error::NumberTooLarge(i.clone()))?)
    }

    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let i = self.input.value().as_signedinteger().ok_or(Error::Syntax)?;
        visitor.visit_i16(i.to_i16().ok_or(Error::NumberTooLarge(i.clone()))?)
    }

    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let i = self.input.value().as_signedinteger().ok_or(Error::Syntax)?;
        visitor.visit_i32(i.to_i32().ok_or(Error::NumberTooLarge(i.clone()))?)
    }

    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let i = self.input.value().as_signedinteger().ok_or(Error::Syntax)?;
        visitor.visit_i64(i.to_i64().ok_or(Error::NumberTooLarge(i.clone()))?)
    }

    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let i = self.input.value().as_signedinteger().ok_or(Error::Syntax)?;
        visitor.visit_u8(i.to_u8().ok_or(Error::NumberTooLarge(i.clone()))?)
    }

    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let i = self.input.value().as_signedinteger().ok_or(Error::Syntax)?;
        visitor.visit_u16(i.to_u16().ok_or(Error::NumberTooLarge(i.clone()))?)
    }

    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let i = self.input.value().as_signedinteger().ok_or(Error::Syntax)?;
        visitor.visit_u32(i.to_u32().ok_or(Error::NumberTooLarge(i.clone()))?)
    }

    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let i = self.input.value().as_signedinteger().ok_or(Error::Syntax)?;
        visitor.visit_u64(i.to_u64().ok_or(Error::NumberTooLarge(i.clone()))?)
    }

    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_f32(self.input.value().as_float().ok_or(Error::Syntax)?)
    }

    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_f64(self.input.value().as_double().ok_or(Error::Syntax)?)
    }

    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let fs =
            self.input.value().as_simple_record("UnicodeScalar", Some(1)).ok_or(Error::Syntax)?;
        if fs.len() != 1 { return Err(Error::Syntax) }
        let c = fs[0].value().as_u32().ok_or(Error::Syntax)?;
        visitor.visit_char(char::try_from(c).or(Err(Error::InvalidUnicodeScalar(c)))?)
    }

    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_borrowed_str(&self.input.value().as_string().ok_or(Error::Syntax)?)
    }

    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        self.deserialize_str(visitor)
    }

    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_borrowed_bytes(&self.input.value().as_bytestring().ok_or(Error::Syntax)?)
    }

    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_byte_buf(self.input.value().as_bytestring().ok_or(Error::Syntax)?.clone())
    }

    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        match self.input.value().as_simple_record("None", Some(0)) {
            Some(_fs) => visitor.visit_none(),
            None => match self.input.value().as_simple_record("Some", Some(1)) {
                Some(fs) => {
                    self.input = &fs[0];
                    visitor.visit_some(self)
                }
                None => Err(Error::Syntax),
            }
        }
    }

    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        if self.input.value().is_simple_record("tuple", Some(0)) {
            visitor.visit_unit()
        } else {
            Err(Error::Syntax)
        }
    }

    fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V)
                                  -> Result<V::Value> where V: Visitor<'de>
    {
        if self.input.value().is_simple_record(name, Some(0)) {
            visitor.visit_unit()
        } else {
            Err(Error::Syntax)
        }
    }

    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V)
                                     -> Result<V::Value> where V: Visitor<'de>
    {
        if name == crate::value::value::MAGIC {
            let mut buf: Vec<u8> = Vec::new();
            crate::value::Encoder::new(&mut buf, None).write(self.input)
                .or_else(|_e| Err(Error::Message("Internal error".to_string())))?;
            visitor.visit_byte_buf(buf)
        } else {
            let fs = self.input.value().as_simple_record(name, Some(1)).ok_or(Error::Syntax)?;
            self.input = &fs[0];
            visitor.visit_newtype_struct(self)
        }
    }

    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
        let vs = self.input.value().as_sequence().ok_or(Error::Syntax)?;
        visitor.visit_seq(VecSeq::new(self, vs))
    }

    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        let fs = self.input.value().as_simple_record("tuple", Some(len)).ok_or(Error::Syntax)?;
        visitor.visit_seq(VecSeq::new(self, fs))
    }

    fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V)
                                   -> Result<V::Value> where V: Visitor<'de>
    {
        let fs = self.input.value().as_simple_record(name, Some(len)).ok_or(Error::Syntax)?;
        visitor.visit_seq(VecSeq::new(self, fs))
    }

    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
        let d = self.input.value().as_dictionary().ok_or(Error::Syntax)?;
        visitor.visit_map(DictMap::new(self, d))
    }

    fn deserialize_struct<V>(self,
                             name: &'static str,
                             fields: &'static [&'static str],
                             visitor: V)
                             -> Result<V::Value> where V: Visitor<'de>
    {
        let fs =
            self.input.value().as_simple_record(name, Some(fields.len())).ok_or(Error::Syntax)?;
        visitor.visit_seq(VecSeq::new(self, fs))
    }

    fn deserialize_enum<V>(self,
                           _name: &'static str,
                           _variants: &'static [&'static str],
                           visitor: V)
                           -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_enum(self)
    }

    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        self.deserialize_str(visitor)
    }

    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_none()
    }
}

pub struct VecSeq<'a, 'de: 'a> {
    index: usize,
    vec: &'de Vec<AValue>,
    de: &'a mut Deserializer<'de>,
}

impl<'de, 'a> VecSeq<'a, 'de> {
    fn new(de: &'a mut Deserializer<'de>, vec: &'de Vec<AValue>) -> Self {
        VecSeq{ index: 0, vec, de }
    }
}

impl<'de, 'a> SeqAccess<'de> for VecSeq<'a, 'de> {
    type Error = Error;

    fn next_element_seed<T>(&mut self, seed: T)
                            -> Result<Option<T::Value>> where T: DeserializeSeed<'de>
    {
        if self.index == self.vec.len() {
            return Ok(None)
        }

        self.de.input = &self.vec[self.index];
        self.index = self.index + 1;
        let value = seed.deserialize(&mut *self.de)?;
        Ok(Some(value))
    }
}

pub struct DictMap<'a, 'de: 'a> {
    pending: Option<&'de AValue>,
    iter: Box<dyn Iterator<Item = (&'de AValue, &'de AValue)> + 'a>,
    de: &'a mut Deserializer<'de>,
}

impl<'de, 'a> DictMap<'a, 'de> {
    fn new(de: &'a mut Deserializer<'de>, d: &'de Dictionary) -> Self {
        DictMap{ pending: None, iter: Box::new(d.into_iter()), de }
    }
}

impl<'de, 'a> MapAccess<'de> for DictMap<'a, 'de> {
    type Error = Error;

    fn next_key_seed<K>(&mut self, seed: K)
                        -> Result<Option<K::Value>> where K: DeserializeSeed<'de>
    {
        match self.iter.next() {
            None => Ok(None),
            Some((k, v)) => {
                self.pending = Some(v);
                self.de.input = k;
                Ok(Some(seed.deserialize(&mut *self.de)?))
            }
        }
    }

    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> where V: DeserializeSeed<'de> {
        let v = self.pending.unwrap();
        self.pending = None;
        self.de.input = v;
        Ok(seed.deserialize(&mut *self.de)?)
    }
}

impl<'a, 'de> EnumAccess<'de> for &'a mut Deserializer<'de> {
    type Error = Error;
    type Variant = Self;

    fn variant_seed<V>(self, seed: V)
                       -> Result<(V::Value, Self::Variant)> where V: DeserializeSeed<'de>
    {
        let v = self.input;
        let (lp, _) = v.value().as_record().ok_or(Error::Syntax)?;
        self.input = lp;
        let variant = seed.deserialize(&mut *self)?;
        self.input = v;
        Ok((variant, self))
    }
}

impl<'a, 'de> VariantAccess<'de> for &'a mut Deserializer<'de> {
    type Error = Error;

    fn unit_variant(self) -> Result<()> {
        Ok(())
    }

    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value> where T: DeserializeSeed<'de> {
        let (_, fs) = self.input.value().as_record().unwrap();
        self.input = &fs[0];
        seed.deserialize(&mut *self)
    }

    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
        visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record().unwrap().1))
    }

    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V)
                         -> Result<V::Value> where V: Visitor<'de>
    {
        visitor.visit_seq(VecSeq::new(self, &self.input.value().as_record().unwrap().1))
    }
}