use serde_base::ser;
use std::fmt::Display;
use std::str::FromStr;

use {Date, Error, EventWriter, PlistEvent};
use date::serde_impls::DATE_NEWTYPE_STRUCT_NAME;

impl ser::Error for Error {
    fn custom<T: Display>(msg: T) -> Self {
        Error::Serde(msg.to_string())
    }
}

pub struct Serializer<W: EventWriter> {
    writer: W,
}

impl<W: EventWriter> Serializer<W> {
    pub fn new(writer: W) -> Serializer<W> {
        Serializer { writer: writer }
    }

    fn emit(&mut self, event: PlistEvent) -> Result<(), Error> {
        self.writer.write(&event)?;
        Ok(())
    }

    pub fn into_inner(self) -> W {
        self.writer
    }

    // Emit {key: value}
    fn single_key_dict(&mut self, key: String) -> Result<(), Error> {
        self.emit(PlistEvent::StartDictionary(Some(1)))?;
        self.emit(PlistEvent::StringValue(key))?;
        Ok(())
    }

    fn single_key_dict_end(&mut self) -> Result<(), Error> {
        self.emit(PlistEvent::EndDictionary)?;
        Ok(())
    }
}

impl<'a, W: EventWriter> ser::Serializer for &'a mut Serializer<W> {
    type Ok = ();
    type Error = Error;

    type SerializeSeq = Compound<'a, W>;
    type SerializeTuple = Compound<'a, W>;
    type SerializeTupleStruct = Compound<'a, W>;
    type SerializeTupleVariant = Compound<'a, W>;
    type SerializeMap = Compound<'a, W>;
    type SerializeStruct = Compound<'a, W>;
    type SerializeStructVariant = Compound<'a, W>;

    fn serialize_bool(self, v: bool) -> Result<(), Self::Error> {
        self.emit(PlistEvent::BooleanValue(v))
    }

    fn serialize_i8(self, v: i8) -> Result<(), Self::Error> {
        self.serialize_i64(v as i64)
    }

    fn serialize_i16(self, v: i16) -> Result<(), Self::Error> {
        self.serialize_i64(v as i64)
    }

    fn serialize_i32(self, v: i32) -> Result<(), Self::Error> {
        self.serialize_i64(v as i64)
    }

    fn serialize_i64(self, v: i64) -> Result<(), Self::Error> {
        self.emit(PlistEvent::IntegerValue(v))
    }

    fn serialize_u8(self, v: u8) -> Result<(), Self::Error> {
        self.serialize_u64(v as u64)
    }

    fn serialize_u16(self, v: u16) -> Result<(), Self::Error> {
        self.serialize_u64(v as u64)
    }

    fn serialize_u32(self, v: u32) -> Result<(), Self::Error> {
        self.serialize_u64(v as u64)
    }

    fn serialize_u64(self, v: u64) -> Result<(), Self::Error> {
        self.emit(PlistEvent::IntegerValue(v as i64))
    }

    fn serialize_f32(self, v: f32) -> Result<(), Self::Error> {
        self.serialize_f64(v as f64)
    }

    fn serialize_f64(self, v: f64) -> Result<(), Self::Error> {
        self.emit(PlistEvent::RealValue(v))
    }

    fn serialize_char(self, v: char) -> Result<(), Self::Error> {
        self.emit(PlistEvent::StringValue(v.to_string()))
    }

    fn serialize_str(self, v: &str) -> Result<(), Self::Error> {
        self.emit(PlistEvent::StringValue(v.to_owned()))
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<(), Self::Error> {
        self.emit(PlistEvent::DataValue(v.to_owned()))
    }

    fn serialize_none(self) -> Result<(), Self::Error> {
        self.single_key_dict("None".to_owned())?;
        self.serialize_unit()?;
        self.single_key_dict_end()
    }

    fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<(), Self::Error> {
        self.single_key_dict("Some".to_owned())?;
        value.serialize(&mut *self)?;
        self.single_key_dict_end()
    }

    fn serialize_unit(self) -> Result<(), Self::Error> {
        // Emit empty string
        self.emit(PlistEvent::StringValue(String::new()))
    }

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

    fn serialize_unit_variant(self,
                              _name: &'static str,
                              _variant_index: u32,
                              variant: &'static str)
                              -> Result<(), Self::Error> {
        self.single_key_dict(variant.to_owned())?;
        self.serialize_unit()?;
        self.single_key_dict_end()?;
        Ok(())
    }

    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(self,
                                                            name: &'static str,
                                                            value: &T)
                                                            -> Result<(), Self::Error> {
        if name == DATE_NEWTYPE_STRUCT_NAME {
            value.serialize(DateSerializer { ser: &mut *self })
        } else {
            value.serialize(self)
        }
    }

    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self,
                                                             _name: &'static str,
                                                             _variant_index: u32,
                                                             variant: &'static str,
                                                             value: &T)
                                                             -> Result<(), Self::Error> {
        self.single_key_dict(variant.to_owned())?;
        value.serialize(&mut *self)?;
        self.single_key_dict_end()
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        let len = len.map(|len| len as u64);
        self.emit(PlistEvent::StartArray(len))?;
        Ok(Compound { ser: self })
    }

    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        self.serialize_seq(Some(len))
    }

    fn serialize_tuple_struct(self,
                              _name: &'static str,
                              len: usize)
                              -> Result<Self::SerializeTupleStruct, Self::Error> {
        self.serialize_tuple(len)
    }

    fn serialize_tuple_variant(self,
                               _name: &'static str,
                               _variant_index: u32,
                               variant: &'static str,
                               len: usize)
                               -> Result<Self::SerializeTupleVariant, Self::Error> {
        self.single_key_dict(variant.to_owned())?;
        self.serialize_tuple(len)
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        let len = len.map(|len| len as u64);
        self.emit(PlistEvent::StartDictionary(len))?;
        Ok(Compound { ser: self })
    }

    fn serialize_struct(self,
                        _name: &'static str,
                        _len: usize)
                        -> Result<Self::SerializeStruct, Self::Error> {
        // The number of struct fields is not known as fields with None values are ignored.
        self.serialize_map(None)
    }

    fn serialize_struct_variant(self,
                                name: &'static str,
                                _variant_index: u32,
                                variant: &'static str,
                                len: usize)
                                -> Result<Self::SerializeStructVariant, Self::Error> {
        self.single_key_dict(variant.to_owned())?;
        self.serialize_struct(name, len)
    }
}

struct StructFieldSerializer<'a, W: 'a + EventWriter> {
    ser: &'a mut Serializer<W>,
    field_name: &'static str,
}

impl<'a, W: EventWriter> StructFieldSerializer<'a, W> {
    fn use_ser(self) -> Result<&'a mut Serializer<W>, Error> {
        // We are going to serialize something so write the struct field name.
        self.ser.emit(PlistEvent::StringValue(self.field_name.to_owned()))?;
        Ok(self.ser)
    }
}

impl<'a, W: EventWriter> ser::Serializer for StructFieldSerializer<'a, W> {
    type Ok = ();
    type Error = Error;

    type SerializeSeq = Compound<'a, W>;
    type SerializeTuple = Compound<'a, W>;
    type SerializeTupleStruct = Compound<'a, W>;
    type SerializeTupleVariant = Compound<'a, W>;
    type SerializeMap = Compound<'a, W>;
    type SerializeStruct = Compound<'a, W>;
    type SerializeStructVariant = Compound<'a, W>;

    fn serialize_bool(self, v: bool) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_bool(v)
    }

    fn serialize_i8(self, v: i8) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_i8(v)
    }

    fn serialize_i16(self, v: i16) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_i16(v)
    }

    fn serialize_i32(self, v: i32) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_i32(v)
    }

    fn serialize_i64(self, v: i64) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_i64(v)
    }

    fn serialize_u8(self, v: u8) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_u8(v)
    }

    fn serialize_u16(self, v: u16) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_u16(v)
    }

    fn serialize_u32(self, v: u32) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_u32(v)
    }

    fn serialize_u64(self, v: u64) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_u64(v)
    }

    fn serialize_f32(self, v: f32) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_f32(v)
    }

    fn serialize_f64(self, v: f64) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_f64(v)
    }

    fn serialize_char(self, v: char) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_char(v)
    }

    fn serialize_str(self, v: &str) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_str(v)
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_bytes(v)
    }

    fn serialize_none(self) -> Result<(), Self::Error> {
        // Don't write a dict for None if the Option is in a struct.
        Ok(())
    }

    fn serialize_some<T: ?Sized + ser::Serialize>(self, value: &T) -> Result<(), Self::Error> {
        let ser = self.use_ser()?;
        value.serialize(ser)
    }

    fn serialize_unit(self) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_unit()
    }

    fn serialize_unit_struct(self, name: &'static str) -> Result<(), Self::Error> {
        self.use_ser()?.serialize_unit_struct(name)
    }

    fn serialize_unit_variant(self,
                              name: &'static str,
                              variant_index: u32,
                              variant: &'static str)
                              -> Result<(), Self::Error> {
        self.use_ser()?.serialize_unit_variant(name, variant_index, variant)
    }

    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(self,
                                                            name: &'static str,
                                                            value: &T)
                                                            -> Result<(), Self::Error> {
        self.use_ser()?.serialize_newtype_struct(name, value)
    }

    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self,
                                                             name: &'static str,
                                                             variant_index: u32,
                                                             variant: &'static str,
                                                             value: &T)
                                                             -> Result<(), Self::Error> {
        self.use_ser()?.serialize_newtype_variant(name, variant_index, variant, value)
    }

    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        self.use_ser()?.serialize_seq(len)
    }

    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        self.use_ser()?.serialize_tuple(len)
    }

    fn serialize_tuple_struct(self,
                              name: &'static str,
                              len: usize)
                              -> Result<Self::SerializeTupleStruct, Self::Error> {
        self.use_ser()?.serialize_tuple_struct(name, len)
    }

    fn serialize_tuple_variant(self,
                               name: &'static str,
                               variant_index: u32,
                               variant: &'static str,
                               len: usize)
                               -> Result<Self::SerializeTupleVariant, Self::Error> {
        self.use_ser()?.serialize_tuple_variant(name, variant_index, variant, len)
    }

    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        self.use_ser()?.serialize_map(len)
    }

    fn serialize_struct(self,
                        name: &'static str,
                        len: usize)
                        -> Result<Self::SerializeStruct, Self::Error> {
        self.use_ser()?.serialize_struct(name, len)
    }

    fn serialize_struct_variant(self,
                                name: &'static str,
                                variant_index: u32,
                                variant: &'static str,
                                len: usize)
                                -> Result<Self::SerializeStructVariant, Self::Error> {
        self.use_ser()?.serialize_struct_variant(name, variant_index, variant, len)
    }
}

struct DateSerializer<'a, W: 'a + EventWriter> {
    ser: &'a mut Serializer<W>,
}

impl<'a, W: EventWriter> DateSerializer<'a, W> {
    fn expecting_date_error(&self) -> Error {
        ser::Error::custom("plist date string expected")
    }
}

impl<'a, W: EventWriter> ser::Serializer for DateSerializer<'a, W> {
    type Ok = ();
    type Error = Error;

    type SerializeSeq = ser::Impossible<(), Error>;
    type SerializeTuple = ser::Impossible<(), Error>;
    type SerializeTupleStruct = ser::Impossible<(), Error>;
    type SerializeTupleVariant = ser::Impossible<(), Error>;
    type SerializeMap = ser::Impossible<(), Error>;
    type SerializeStruct = ser::Impossible<(), Error>;
    type SerializeStructVariant = ser::Impossible<(), Error>;

    fn serialize_bool(self, _: bool) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_i8(self, _: i8) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_i16(self, _: i16) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_i32(self, _: i32) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_i64(self, _: i64) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_u8(self, _: u8) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_u16(self, _: u16) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_u32(self, _: u32) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_u64(self, _: u64) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_f32(self, _: f32) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_f64(self, _: f64) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_char(self, _: char) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_str(self, v: &str) -> Result<(), Self::Error> {
        let date = Date::from_str(v).map_err(|_| self.expecting_date_error())?;
        self.ser.emit(PlistEvent::DateValue(date))
    }

    fn serialize_bytes(self, _: &[u8]) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_none(self) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_some<T: ?Sized + ser::Serialize>(self, _: &T) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_unit(self) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_unit_struct(self, _: &'static str) -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_unit_variant(self,
                              _: &'static str,
                              _: u32,
                              _: &'static str)
                              -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_newtype_struct<T: ?Sized + ser::Serialize>(self,
                                                            _: &'static str,
                                                            _: &T)
                                                            -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_newtype_variant<T: ?Sized + ser::Serialize>(self,
                                                             _: &'static str,
                                                             _: u32,
                                                             _: &'static str,
                                                             _: &T)
                                                             -> Result<(), Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_tuple_struct(self,
                              _: &'static str,
                              _: usize)
                              -> Result<Self::SerializeTupleStruct, Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_tuple_variant(self,
                               _: &'static str,
                               _: u32,
                               _: &'static str,
                               _: usize)
                               -> Result<Self::SerializeTupleVariant, Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_struct(self,
                        _: &'static str,
                        _: usize)
                        -> Result<Self::SerializeStruct, Self::Error> {
        Err(self.expecting_date_error())
    }

    fn serialize_struct_variant(self,
                                _: &'static str,
                                _: u32,
                                _: &'static str,
                                _: usize)
                                -> Result<Self::SerializeStructVariant, Self::Error> {
        Err(self.expecting_date_error())
    }
}

#[doc(hidden)]
pub struct Compound<'a, W: 'a + EventWriter> {
    ser: &'a mut Serializer<W>,
}

impl<'a, W: EventWriter> ser::SerializeSeq for Compound<'a, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
                                                     value: &T)
                                                     -> Result<(), Self::Error> {
        value.serialize(&mut *self.ser)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        self.ser.emit(PlistEvent::EndArray)
    }
}

impl<'a, W: EventWriter> ser::SerializeTuple for Compound<'a, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized + ser::Serialize>(&mut self,
                                                     value: &T)
                                                     -> Result<(), Self::Error> {
        <Self as ser::SerializeSeq>::serialize_element(self, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        <Self as ser::SerializeSeq>::end(self)
    }
}

impl<'a, W: EventWriter> ser::SerializeTupleStruct for Compound<'a, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
                                                   value: &T)
                                                   -> Result<(), Self::Error> {
        <Self as ser::SerializeSeq>::serialize_element(self, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        <Self as ser::SerializeSeq>::end(self)
    }
}

impl<'a, W: EventWriter> ser::SerializeTupleVariant for Compound<'a, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
                                                   value: &T)
                                                   -> Result<(), Self::Error> {
        <Self as ser::SerializeSeq>::serialize_element(self, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        self.ser.emit(PlistEvent::EndArray)?;
        self.ser.single_key_dict_end()
    }
}

impl<'a, W: EventWriter> ser::SerializeMap for Compound<'a, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_key<T: ?Sized + ser::Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
        key.serialize(&mut *self.ser)
    }

    fn serialize_value<T: ?Sized + ser::Serialize>(&mut self,
                                                   value: &T)
                                                   -> Result<(), Self::Error> {
        value.serialize(&mut *self.ser)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        self.ser.emit(PlistEvent::EndDictionary)
    }
}

impl<'a, W: EventWriter> ser::SerializeStruct for Compound<'a, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
                                                   key: &'static str,
                                                   value: &T)
                                                   -> Result<(), Self::Error> {
        // We don't want to serialize None if the Option is a struct field as this is how null
        // fields are represented in plists.
        value.serialize(StructFieldSerializer {
            field_name: key,
            ser: &mut *self.ser,
        })
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        <Self as ser::SerializeMap>::end(self)
    }
}

impl<'a, W: EventWriter> ser::SerializeStructVariant for Compound<'a, W> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + ser::Serialize>(&mut self,
                                                   key: &'static str,
                                                   value: &T)
                                                   -> Result<(), Self::Error> {
        <Self as ser::SerializeStruct>::serialize_field(self, key, value)
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        self.ser.emit(PlistEvent::EndDictionary)?;
        self.ser.single_key_dict_end()
    }
}