use super::*;


pub fn to_tree<T>(value: &T) -> self::error::Result<NodeRef>
    where T: serde::Serialize
{
    value.serialize(NodeSerializer)
}


struct NodeSerializer;

impl serde::ser::Serializer for NodeSerializer {
    type Ok = NodeRef;
    type Error = self::error::Error;

    type SerializeSeq = SeqSerializer;
    type SerializeTuple = SeqSerializer;
    type SerializeTupleStruct = SeqSerializer;
    type SerializeTupleVariant = SeqSerializer;
    type SerializeMap = MapSerializer;
    type SerializeStruct = MapSerializer;
    type SerializeStructVariant = MapSerializer;

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::boolean(v))
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::integer(v as i64))
    }

    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::integer(v as i64))
    }

    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::integer(v as i64))
    }

    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::integer(v as i64))
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::integer(v as i64))
    }

    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::integer(v as i64))
    }

    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::integer(v as i64))
    }

    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        Ok(if v <= std::i64::MAX as u64 {
            NodeRef::integer(v as i64)
        } else {
            NodeRef::float(v as f64)
        })
    }

    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::float(v as f64))
    }

    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::float(v as f64))
    }

    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::string(v.to_string()))
    }

    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::string(v))
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::binary(v))
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::null())
    }

    fn serialize_some<T: ? Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
        where T: serde::Serialize {
        value.serialize(self)
    }

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::null())
    }

    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::null())
    }

    fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::string(variant))
    }

    fn serialize_newtype_struct<T: ? Sized>(self, _name: &'static str, value: &T) -> Result<Self::Ok, Self::Error>
        where T: serde::Serialize {
        value.serialize(self)
    }

    fn serialize_newtype_variant<T: ? Sized>(self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error>
        where T: serde::Serialize {
        let val = value.serialize(self)?;
        let mut p = Properties::new();
        p.insert(variant.into(), val);
        Ok(NodeRef::object(p))
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        let seqser = SeqSerializer {
            variant: None,
            elems: Elements::with_capacity(len.unwrap_or_default()),
        };
        Ok(seqser)
    }

    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        let seqser = SeqSerializer {
            variant: None,
            elems: Elements::with_capacity(len),
        };
        Ok(seqser)
    }

    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
        let seqser = SeqSerializer {
            variant: None,
            elems: Elements::with_capacity(len),
        };
        Ok(seqser)
    }

    fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
        let seqser = SeqSerializer {
            variant: Some(variant.into()),
            elems: Elements::with_capacity(len),
        };
        Ok(seqser)
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        let mapser = MapSerializer {
            variant: None,
            key: None,
            props: Properties::with_capacity(len.unwrap_or_default()),
        };
        Ok(mapser)
    }

    fn serialize_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeStruct, Self::Error> {
        let mapser = MapSerializer {
            variant: None,
            key: None,
            props: Properties::with_capacity(len),
        };
        Ok(mapser)
    }

    fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
        let mapser = MapSerializer {
            variant: Some(variant.into()),
            key: None,
            props: Properties::with_capacity(len),
        };
        Ok(mapser)
    }
}


struct SymbolSerializer;

impl serde::Serializer for SymbolSerializer {
    type Ok = Symbol;
    type Error = self::error::Error;

    type SerializeSeq = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTupleStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;

    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_i8(self, _v: i8) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_u8(self, _v: u8) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_u16(self, _v: u16) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_u32(self, _v: u32) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        Ok(Symbol::from(v))
    }

    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_some<T: ? Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
        where T: serde::Serialize {
        unreachable!()
    }

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str) -> Result<Self::Ok, Self::Error> {
        unreachable!()
    }

    fn serialize_newtype_struct<T: ? Sized>(self, _name: &'static str, _value: &T) -> Result<Self::Ok, Self::Error>
        where T: serde::Serialize {
        unreachable!()
    }

    fn serialize_newtype_variant<T: ? Sized>(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _value: &T) -> Result<Self::Ok, Self::Error>
        where T: serde::Serialize {
        unreachable!()
    }

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        unreachable!()
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        unreachable!()
    }

    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
        unreachable!()
    }

    fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
        unreachable!()
    }

    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        unreachable!()
    }

    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct, Self::Error> {
        unreachable!()
    }

    fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
        unreachable!()
    }
}


struct SeqSerializer {
    variant: Option<Symbol>,
    elems: Elements,
}

impl serde::ser::SerializeSeq for SeqSerializer {
    type Ok = NodeRef;
    type Error = self::error::Error;

    fn serialize_element<T: ? Sized>(&mut self, value: &T) -> Result<(), Self::Error>
        where T: serde::Serialize {
        self.elems.push(value.serialize(NodeSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::array(self.elems))
    }
}

impl serde::ser::SerializeTuple for SeqSerializer {
    type Ok = NodeRef;
    type Error = self::error::Error;

    fn serialize_element<T: ? Sized>(&mut self, value: &T) -> Result<(), Self::Error>
        where T: serde::Serialize {
        self.elems.push(value.serialize(NodeSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::array(self.elems))
    }
}

impl serde::ser::SerializeTupleStruct for SeqSerializer {
    type Ok = NodeRef;
    type Error = self::error::Error;

    fn serialize_field<T: ? Sized>(&mut self, value: &T) -> Result<(), Self::Error>
        where T: serde::Serialize {
        self.elems.push(value.serialize(NodeSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::array(self.elems))
    }
}

impl serde::ser::SerializeTupleVariant for SeqSerializer {
    type Ok = NodeRef;
    type Error = self::error::Error;

    fn serialize_field<T: ? Sized>(&mut self, value: &T) -> Result<(), Self::Error>
        where T: serde::Serialize {
        self.elems.push(value.serialize(NodeSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        let mut p = Properties::new();
        p.insert(self.variant.unwrap(), NodeRef::array(self.elems));
        Ok(NodeRef::object(p))
    }
}


struct MapSerializer {
    variant: Option<Symbol>,
    key: Option<Symbol>,
    props: Properties,
}

impl serde::ser::SerializeMap for MapSerializer {
    type Ok = NodeRef;
    type Error = self::error::Error;

    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
        where T: serde::Serialize {
        let key = key.serialize(SymbolSerializer)?;
        self.key = Some(key);
        Ok(())
    }

    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
        where T: serde::Serialize {
        let val = value.serialize(NodeSerializer)?;
        self.props.insert(self.key.take().unwrap(), val);
        Ok(())
    }

    fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
        where K: serde::Serialize, V: serde::Serialize {
        let key = key.serialize(SymbolSerializer)?;
        let val = value.serialize(NodeSerializer)?;
        self.props.insert(key, val);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::object(self.props))
    }
}

impl serde::ser::SerializeStruct for MapSerializer {
    type Ok = NodeRef;
    type Error = self::error::Error;

    fn serialize_field<T: ? Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
        where T: serde::Serialize {
        self.props.insert(key.into(), value.serialize(NodeSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        Ok(NodeRef::object(self.props))
    }
}

impl serde::ser::SerializeStructVariant for MapSerializer {
    type Ok = NodeRef;
    type Error = self::error::Error;

    fn serialize_field<T: ? Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
        where T: serde::Serialize {
        self.props.insert(key.into(), value.serialize(NodeSerializer)?);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        let mut p = Properties::new();
        p.insert(self.variant.unwrap(), NodeRef::object(self.props));
        Ok(NodeRef::object(p))
    }
}