//! ser.rs --- SXP Serializer

 use crate::{

   err::ErrorCode,

   fmt::{DefaultFormatter, WriteFormatter},

   tok::{format_escaped_str, format_escaped_str_contents},

   Error, Result,

 };

 use core::{

   fmt::{self, Display},

   num::FpCategory,

 };

 use serde::ser::{self, Impossible, Serialize};

 use std::io::{self, Write};

 #[inline]

 pub fn to_writer<W: Write, S: ?Sized + Serialize>(

   writer: W,

   value: &S,

 ) -> Result<()> {

   let mut ser = Serializer::new(writer);

   value.serialize(&mut ser)

 }

 /// Serialize the given data structure as a canonical SXP byte vector.

 #[inline]

 pub fn to_vec<S: ?Sized + Serialize>(value: &S) -> Result<Vec<u8>> {

   let mut writer = Vec::with_capacity(128);

   e!(to_writer(&mut writer, value));

   Ok(writer)

 }

 #[inline]

 pub fn to_string<S: ?Sized + Serialize>(value: &S) -> Result<String> {

   let mut writer = Vec::new(); // TODO: with-capacity 128? bench

   to_writer(&mut writer, value)?;

   // We then check that the serialized string is the same as what we expect

   let string = unsafe { String::from_utf8_unchecked(writer) };

   Ok(string)

 }

 pub struct Serializer<W, F = DefaultFormatter> {

   writer: W,

   formatter: F,

 }

 impl<W: Write> Serializer<W> {

   #[inline]

   fn new(writer: W) -> Self {

     Serializer::with_formatter(writer, DefaultFormatter)

   }

 }

 impl<W: Write, F: WriteFormatter> Serializer<W, F> {

   fn with_formatter(writer: W, formatter: F) -> Self {

     Serializer { writer, formatter }

   }

   #[inline]

   pub fn into_inner(self) -> W {

     self.writer

   }

   #[inline]

   pub fn serialize_symbol(&mut self, value: &str) -> Result<()> {

     self

       .formatter

       .write_symbol(&mut self.writer, value)

       .map_err(Error::io)

   }

 }

 // impl<'a, W:Write> Serializer<W, PrettyFormatter<'a>> {...}

 impl<'ser, W: Write, F: WriteFormatter> serde::ser::Serializer

   for &'ser mut Serializer<W, F>

 {

   type Ok = (); // could be usize for bytes written

   type Error = Error;

   type SerializeSeq = Seq<'ser, W, F>;

   type SerializeTuple = Seq<'ser, W, F>;

   type SerializeTupleStruct = Seq<'ser, W, F>;

   type SerializeTupleVariant = Seq<'ser, W, F>;

   type SerializeMap = Seq<'ser, W, F>;

   type SerializeStruct = Seq<'ser, W, F>;

   type SerializeStructVariant = Seq<'ser, W, F>;

   // TODO

   fn serialize_bool(self, v: bool) -> Result<()> {

     self

       .formatter

       .write_bool(&mut self.writer, v)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_i8(self, value: i8) -> Result<()> {

     self

       .formatter

       .write_i8(&mut self.writer, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_i16(self, value: i16) -> Result<()> {

     self

       .formatter

       .write_i16(&mut self.writer, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_i32(self, value: i32) -> Result<()> {

     self

       .formatter

       .write_i32(&mut self.writer, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_i64(self, value: i64) -> Result<()> {

     self

       .formatter

       .write_i64(&mut self.writer, value)

       .map_err(Error::io)

   }

   fn serialize_i128(self, value: i128) -> Result<()> {

     self

       .formatter

       .write_i128(&mut self.writer, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_u8(self, value: u8) -> Result<()> {

     self

       .formatter

       .write_u8(&mut self.writer, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_u16(self, value: u16) -> Result<()> {

     self

       .formatter

       .write_u16(&mut self.writer, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_u32(self, value: u32) -> Result<()> {

     self

       .formatter

       .write_u32(&mut self.writer, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_u64(self, value: u64) -> Result<()> {

     self

       .formatter

       .write_u64(&mut self.writer, value)

       .map_err(Error::io)

   }

   fn serialize_u128(self, value: u128) -> Result<()> {

     self

       .formatter

       .write_u128(&mut self.writer, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_f32(self, value: f32) -> Result<()> {

     match value.classify() {

       // TODO

       FpCategory::Nan | FpCategory::Infinite => self

         .formatter

         .write_nil(&mut self.writer)

         .map_err(Error::io),

       _ => self

         .formatter

         .write_f32(&mut self.writer, value)

         .map_err(Error::io),

     }

   }

   #[inline]

   fn serialize_f64(self, value: f64) -> Result<()> {

     match value.classify() {

       FpCategory::Nan | FpCategory::Infinite => self

         .formatter

         .write_nil(&mut self.writer)

         .map_err(Error::io),

       _ => self

         .formatter

         .write_f64(&mut self.writer, value)

         .map_err(Error::io),

     }

   }

   #[inline]

   fn serialize_char(self, value: char) -> Result<()> {

     // A char encoded as UTF-8 takes 4 bytes at most.

     let mut buf = [0; 4];

     self.serialize_str(value.encode_utf8(&mut buf))

   }

   #[inline]

   fn serialize_str(self, value: &str) -> Result<()> {

     format_escaped_str(&mut self.writer, &mut self.formatter, value)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_bytes(self, value: &[u8]) -> Result<()> {

     use serde::ser::SerializeSeq;

     let mut seq = e!(self.serialize_seq(Some(value.len())));

     for byte in value {

       e!(seq.serialize_element(byte));

     }

     seq.end()

   }

   #[inline]

   fn serialize_unit(self) -> Result<()> {

     self

       .formatter

       .write_nil(&mut self.writer)

       .map_err(Error::io)

   }

   #[inline]

   fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {

     self.serialize_unit()

   }

   #[inline]

   fn serialize_unit_variant(

     self,

     _name: &'static str,

     _variant_index: u32,

     variant: &'static str,

   ) -> Result<()> {

     self.serialize_symbol(variant)

   }

   /// Serialize newtypes without an object wrapper.

   #[inline]

   fn serialize_newtype_struct<T>(

     self,

     _name: &'static str,

     value: &T,

   ) -> Result<()>

   where

     T: ?Sized + Serialize,

   {

     value.serialize(self)

   }

   #[inline]

   fn serialize_newtype_variant<T>(

     self,

     _name: &'static str,

     _variant_index: u32,

     variant: &'static str,

     value: &T,

   ) -> Result<()>

   where

     T: ?Sized + Serialize,

   {

     e!(self

       .formatter

       .begin_list(&mut self.writer)

       .map_err(Error::io));

     e!(self.serialize_symbol(variant));

     // e!(self

     //     .formatter

     //     .end_object_key(&mut self.writer)

     //     .map_err(|e| e.into()));

     // e!(self

     //     .formatter

     //     .begin_object_value(&mut self.writer)

     //     .map_err(|e| e.into()));

     e!(self

       .formatter

       .begin_list_element(&mut self.writer, false)

       .map_err(Error::io));

     e!(value.serialize(&mut *self));

     // e!(self

     //     .formatter

     //     .end_object_value(&mut self.writer)

     //     .map_err(|e| e.into()));

     self.formatter.end_list(&mut self.writer).map_err(Error::io)

   }

   #[inline]

   fn serialize_none(self) -> Result<()> {

     self.serialize_unit()

   }

   #[inline]

   fn serialize_some<T>(self, value: &T) -> Result<()>

   where

     T: ?Sized + Serialize,

   {

     value.serialize(self)

   }

   #[inline]

   fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {

     // TODO: impl nil for seq of 0 length?

     e!(self

       .formatter

       .begin_list(&mut self.writer)

       .map_err(Error::io));

     if len == Some(0) {

       e!(self.formatter.end_list(&mut self.writer).map_err(Error::io));

       Ok(Seq {

         ser: self,

         state: State::Nil,

       })

     } else {

       Ok(Seq {

         ser: self,

         state: State::Car,

       })

     }

   }

   #[inline]

   fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {

     self.serialize_seq(Some(len))

   }

   #[inline]

   fn serialize_tuple_struct(

     self,

     _name: &'static str,

     len: usize,

   ) -> Result<Self::SerializeTupleStruct> {

     self.serialize_seq(Some(len))

   }

   #[inline]

   fn serialize_tuple_variant(

     self,

     _name: &'static str,

     _variant_index: u32,

     variant: &'static str,

     len: usize,

   ) -> Result<Self::SerializeTupleVariant> {

     e!(self

       .formatter

       .begin_list(&mut self.writer)

       .map_err(Error::io));

     e!(self.serialize_symbol(variant));

     // e!(self

     //     .formatter

     //     .end_object_key(&mut self.writer)

     //     .map_err(|e| e.into()));

     // e!(self

     //     .formatter

     //     .begin_object_value(&mut self.writer)

     //     .map_err(|e| e.into()));

     e!(self

       .formatter

       .begin_list_element(&mut self.writer, false)

       .map_err(Error::io));

     self.serialize_seq(Some(len))

   }

   #[inline]

   fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {

     e!(self

       .formatter

       .begin_list(&mut self.writer)

       .map_err(Error::io));

     if len == Some(0) {

       e!(self.formatter.end_list(&mut self.writer).map_err(Error::io));

       Ok(Seq {

         ser: self,

         state: State::Nil,

       })

     } else {

       Ok(Seq {