doge 0.1.0

use error;
use serde;
use std;

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

impl<'de> Deserializer<'de> {
    pub fn from_str(input: &'de str) -> Self {
        Deserializer { input }
    }
}

pub fn from_str<'a, T>(s: &'a str) -> error::Result<T>
where
    T: serde::de::Deserialize<'a>,
{
    let mut deserializer = Deserializer::from_str(s);
    let t = T::deserialize(&mut deserializer)?;
    deserializer.skip_whitespace()?;
    if deserializer.input.is_empty() {
        Ok(t)
    } else {
        Err(error::Error::TrailingChars)
    }
}

trait IntFromStrRadix
where
    Self: std::marker::Sized,
{
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError>;
}

trait FloatFromStrRadix
where
    Self: std::marker::Sized,
{
    fn from_str_radix(src: &str, radix: u8) -> Result<Self, lexical::Error>;
}

impl IntFromStrRadix for i64 {
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError> {
        i64::from_str_radix(src, radix)
    }
}

impl IntFromStrRadix for i32 {
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError> {
        i32::from_str_radix(src, radix)
    }
}

impl IntFromStrRadix for i16 {
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError> {
        i16::from_str_radix(src, radix)
    }
}

impl IntFromStrRadix for i8 {
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError> {
        i8::from_str_radix(src, radix)
    }
}

impl IntFromStrRadix for u64 {
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError> {
        u64::from_str_radix(src, radix)
    }
}

impl IntFromStrRadix for u32 {
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError> {
        u32::from_str_radix(src, radix)
    }
}

impl IntFromStrRadix for u16 {
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError> {
        u16::from_str_radix(src, radix)
    }
}

impl IntFromStrRadix for u8 {
    fn from_str_radix(src: &str, radix: u32) -> Result<Self, std::num::ParseIntError> {
        u8::from_str_radix(src, radix)
    }
}

impl FloatFromStrRadix for f32 {
    fn from_str_radix(src: &str, radix: u8) -> Result<Self, lexical::Error> {
        lexical::parse_radix(src, radix)
    }
}

impl FloatFromStrRadix for f64 {
    fn from_str_radix(src: &str, radix: u8) -> Result<Self, lexical::Error> {
        lexical::parse_radix(src, radix)
    }
}

impl<'de> Deserializer<'de> {
    fn peek_char(&mut self) -> error::Result<char> {
        self.input.chars().next().ok_or(error::Error::Eof)
    }

    fn is_next(&self, pattern: &str) -> bool {
        self.input.starts_with(pattern)
    }

    fn next_char(&mut self) -> error::Result<char> {
        let ch = self.peek_char()?;
        self.input = &self.input[ch.len_utf8()..];
        Ok(ch)
    }

    fn skip_whitespace(&mut self) -> error::Result<()> {
        loop {
            let ch = match self.peek_char() {
                Ok(ch) => ch,
                Err(error::Error::Eof) => return Ok(()),
                Err(err) => return Err(err),
            };
            if ch.is_whitespace() {
                self.input = &self.input[ch.len_utf8()..];
            } else {
                return Ok(());
            }
        }
    }

    fn parse_bool(&mut self) -> error::Result<bool> {
        if self.input.starts_with("yes") {
            self.input = &self.input["yes".len()..];
            Ok(true)
        } else if self.input.starts_with("no") {
            self.input = &self.input["no".len()..];
            Ok(false)
        } else {
            Err(error::Error::IncorrectType("boolean", self.peek_char()?))
        }
    }

    fn parse_string(&mut self) -> error::Result<&'de str> {
        let first_char = self.next_char()?;
        if first_char != '"' {
            return Err(error::Error::IncorrectType("string", first_char));
        }
        match self.input.find('"') {
            // TODO make this actually good
            Some(len) => {
                let s = &self.input[..len];
                self.input = &self.input[len + 1..];
                Ok(s)
            }
            None => Err(error::Error::Eof),
        }
    }

    fn parse_char_literal(&mut self) -> error::Result<char> {
        let first_char = self.next_char()?;
        if first_char != '"' {
            return Err(error::Error::IncorrectType("char", first_char));
        }
        let next_char = self.next_char()?;
        if next_char == '"' {
            return Err(error::Error::Message("char cannot be empty".to_owned()));
        }
        let last_char = self.next_char()?;
        match last_char {
            '"' => Ok(next_char),
            _ => Err(error::Error::Message(
                "char must be only one char".to_owned(),
            )),
        }
    }

    fn parse_int<T>(&mut self) -> error::Result<T>
    where
        T: IntFromStrRadix,
    {
        let first_char = self.next_char()?;
        if !first_char.is_digit(8) && first_char != '-' {
            return Err(error::Error::IncorrectType("int", first_char));
        }

        let mut chars = first_char.to_string();
        loop {
            let peek = self.peek_char();
            let result = match peek {
                Ok(ch) => ch.is_digit(8),
                _ => false,
            };
            if result {
                chars.push(peek.unwrap());
                self.input = &self.input[1..];
            } else {
                return match T::from_str_radix(&chars, 8) {
                    Ok(val) => Ok(val),
                    _ => Err(error::Error::NumberSyntax),
                };
            }
        }
    }

    fn parse_float<T>(&mut self) -> error::Result<T>
    where
        T: FloatFromStrRadix,
    {
        let first_char = self.next_char()?;
        if !first_char.is_digit(8) && first_char != '-' && first_char != '.' {
            return Err(error::Error::IncorrectType("float", first_char));
        }

        let mut chars = first_char.to_string();
        loop {
            if self.is_next("very") || self.is_next("VERY") {
                self.input = &self.input[4..];
                chars.push('e');
            }

            let peek = self.peek_char();
            let result = match peek {
                Ok(ch) => ch.is_digit(8) || ch == '-' || ch == '.',
                _ => false
            };

            if result {
                chars.push(peek.unwrap());
                self.input = &self.input[1..];
            } else {
                return T::from_str_radix(&chars, 8)
                    .map_err(|_| error::Error::NumberSyntax);
            }
        }
    }
}

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

    fn deserialize_bool<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_bool(self.parse_bool()?)
    }

    fn deserialize_str<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_borrowed_str(self.parse_string()?)
    }

    fn deserialize_i8<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_i8(self.parse_int()?)
    }

    fn deserialize_i16<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_i16(self.parse_int()?)
    }

    fn deserialize_i32<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_i32(self.parse_int()?)
    }

    fn deserialize_i64<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_i64(self.parse_int()?)
    }

    fn deserialize_u8<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_u32(self.parse_int()?)
    }

    fn deserialize_u16<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_u32(self.parse_int()?)
    }

    fn deserialize_u32<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_u32(self.parse_int()?)
    }

    fn deserialize_u64<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_u64(self.parse_int()?)
    }

    fn deserialize_f32<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_f32(self.parse_float()?)
    }

    fn deserialize_f64<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_f64(self.parse_float()?)
    }

    fn deserialize_char<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        visitor.visit_char(self.parse_char_literal()?)
    }

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

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

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

    fn deserialize_option<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        if self.input.starts_with("empty") {
            self.input = &self.input["empty".len()..];
            visitor.visit_none()
        } else {
            visitor.visit_some(self)
        }
    }

    fn deserialize_unit<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        if self.input.starts_with("null") {
            self.input = &self.input["null".len()..];
            visitor.visit_unit()
        } else {
            Err(error::Error::IncorrectType("null", self.peek_char()?))
        }
    }

    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_unit(visitor)
    }

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

    fn deserialize_seq<V>(mut self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        if self.input.starts_with("so ") {
            self.input = &self.input["so ".len()..];
            let value = visitor.visit_seq(ArrayContent::new(&mut self))?;
            self.skip_whitespace()?;
            if self.input.starts_with("many") {
                self.input = &self.input["many".len()..];
                Ok(value)
            } else {
                Err(error::Error::Message(
                    "array ended without 'many'".to_owned(),
                ))
            }
        } else {
            Err(error::Error::IncorrectType("array", self.peek_char()?))
        }
    }

    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_seq(visitor)
    }

    fn deserialize_tuple_struct<V>(
        self,
        _name: &'static str,
        _len: usize,
        visitor: V,
    ) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_seq(visitor)
    }

    fn deserialize_map<V>(mut self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        if self.input.starts_with("such ") {
            self.input = &self.input["such ".len()..];
            let value = visitor.visit_map(ArrayContent::new(&mut self))?;

            self.skip_whitespace()?;

            if self.input.starts_with("wow") {
                self.input = &self.input["wow".len()..];
                Ok(value)
            } else {
                Err(error::Error::Message(
                    "object ended without 'wow'".to_owned(),
                ))
            }
        } else {
            Err(error::Error::IncorrectType("object", self.peek_char()?))
        }
    }

    fn deserialize_struct<V>(
        self,
        _name: &'static str,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        self.deserialize_map(visitor)
    }

    fn deserialize_enum<V>(
        self,
        _name: &'static str,
        _variants: &'static [&'static str],
        visitor: V,
    ) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        if self.input.starts_with("such") {
            self.input = &self.input["such".len()..];
            let val = visitor.visit_enum(EnumContent::new(self))?;
            self.skip_whitespace()?;
            if self.input.starts_with("wow") {
                self.input = &self.input["wow".len()..];
                Ok(val)
            } else {
                Err(error::Error::Message("enum ended without 'wow'".to_owned()))
            }
        } else if self.peek_char()? == '"' {
            use serde::de::IntoDeserializer;
            visitor.visit_enum(self.parse_string()?.into_deserializer())
        } else {
            Err(error::Error::IncorrectType("enum", self.peek_char()?))
        }
    }

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

    fn deserialize_any<V>(self, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        let ch = self.peek_char()?;
        if self.input.starts_with("such") {
            self.deserialize_map(visitor)
        } else if self.input.starts_with("so") {
            self.deserialize_seq(visitor)
        } else if self.input.starts_with("yes") || self.input.starts_with("no") {
            self.deserialize_bool(visitor)
        } else if ch == '-' || ch.is_digit(8) || ch == '.' {
            self.deserialize_f64(visitor)
        } else if ch == '"' {
            self.deserialize_str(visitor)
        } else {
            Err(error::Error::IncorrectType("any", self.peek_char()?))
        }
    }

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

struct ArrayContent<'a, 'de: 'a> {
    de: &'a mut Deserializer<'de>,
    first: bool,
}

impl<'a, 'de> ArrayContent<'a, 'de> {
    fn new(de: &'a mut Deserializer<'de>) -> Self {
        ArrayContent { de, first: true }
    }
}

impl<'de, 'a> serde::de::SeqAccess<'de> for ArrayContent<'a, 'de> {
    type Error = error::Error;

    fn next_element_seed<T>(&mut self, seed: T) -> error::Result<Option<T::Value>>
    where
        T: serde::de::DeserializeSeed<'de>,
    {
        self.de.skip_whitespace()?;

        if self.de.input.starts_with("many") {
            return Ok(None);
        }

        if !self.first {
            if self.de.input.starts_with("and") {
                self.de.input = &self.de.input["and".len()..];
            } else if self.de.input.starts_with("also") {
                self.de.input = &self.de.input["also".len()..];
            } else {
                return Err(error::Error::Message(
                    "expected 'and' or 'also' between array elements".to_owned(),
                ));
            }
        }
        self.first = false;
        self.de.skip_whitespace()?;
        seed.deserialize(&mut *self.de).map(Some)
    }
}

impl<'de, 'a> serde::de::MapAccess<'de> for ArrayContent<'a, 'de> {
    type Error = error::Error;

    fn next_key_seed<T>(&mut self, seed: T) -> error::Result<Option<T::Value>>
    where
        T: serde::de::DeserializeSeed<'de>,
    {
        self.de.skip_whitespace()?;
        if self.de.input.starts_with("wow") {
            return Ok(None);
        }

        if !self.first {
            let ch = self.de.next_char()?;
            match ch {
                ',' => {}
                '.' => {}
                '!' => {}
                '?' => {}
                _ => {
                    return Err(error::Error::Message(
                        "expected object delimeter between pairs".to_owned(),
                    ))
                }
            }
        }
        self.first = false;

        self.de.skip_whitespace()?;

        seed.deserialize(&mut *self.de).map(Some)
    }

    fn next_value_seed<T>(&mut self, seed: T) -> error::Result<T::Value>
    where
        T: serde::de::DeserializeSeed<'de>,
    {
        self.de.skip_whitespace()?;
        if !self.de.input.starts_with("is") {
            return Err(error::Error::Message(
                "expected 'is' between object pair".to_owned(),
            ));
        }
        self.de.input = &self.de.input["is".len()..];

        self.de.skip_whitespace()?;

        seed.deserialize(&mut *self.de)
    }
}

struct EnumContent<'a, 'de: 'a> {
    de: &'a mut Deserializer<'de>,
}

impl<'a, 'de> EnumContent<'a, 'de> {
    fn new(de: &'a mut Deserializer<'de>) -> Self {
        EnumContent { de }
    }
}

impl<'de, 'a> serde::de::EnumAccess<'de> for EnumContent<'a, 'de> {
    type Error = error::Error;
    type Variant = Self;

    fn variant_seed<T>(self, seed: T) -> error::Result<(T::Value, Self::Variant)>
    where
        T: serde::de::DeserializeSeed<'de>,
    {
        self.de.skip_whitespace()?;

        let val = seed.deserialize(&mut *self.de)?;

        self.de.skip_whitespace()?;

        if self.de.input.starts_with("is") {
            self.de.input = &self.de.input["is".len()..];
            self.de.skip_whitespace()?;
            Ok((val, self))
        } else {
            Err(error::Error::Message(
                "expected 'is' between object pair".to_owned(),
            ))
        }
    }
}

impl<'de, 'a> serde::de::VariantAccess<'de> for EnumContent<'a, 'de> {
    type Error = error::Error;

    fn newtype_variant_seed<T>(self, seed: T) -> error::Result<T::Value>
    where
        T: serde::de::DeserializeSeed<'de>,
    {
        seed.deserialize(self.de)
    }

    fn tuple_variant<V>(self, _len: usize, visitor: V) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        serde::de::Deserializer::deserialize_seq(self.de, visitor)
    }

    fn struct_variant<V>(
        self,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> error::Result<V::Value>
    where
        V: serde::de::Visitor<'de>,
    {
        serde::de::Deserializer::deserialize_map(self.de, visitor)
    }

    fn unit_variant(self) -> error::Result<()> {
        Err(error::Error::IncorrectType("string", self.de.peek_char()?))
    }
}