litl 0.6.0

use std::collections::BTreeMap;

use serde::{
    ser::{
        SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
        SerializeTupleStruct, SerializeTupleVariant,
    },
    Serializer,
};
use serde_json::ser::{CompactFormatter, Formatter};

type CSerializer<W> = serde_json::Serializer<W, CompactFormatter>;

pub struct MapOrderingSerializer<W> {
    writer: W,
}

impl<W> MapOrderingSerializer<W>
where
    W: std::io::Write,
{
    #[inline]
    pub fn new(writer: W) -> Self {
        MapOrderingSerializer { writer }
    }

    #[inline]
    pub fn inner(&mut self) -> CSerializer<&mut W> {
        serde_json::Serializer::with_formatter(&mut self.writer, CompactFormatter {})
    }
}

impl<'a, W: std::io::Write> Serializer for &'a mut MapOrderingSerializer<W> {
    type Ok = ();
    type Error = serde_json::Error;
    type SerializeSeq = SeqSerializer<'a, W>;
    type SerializeTuple = SeqSerializer<'a, W>;
    type SerializeTupleStruct = SeqSerializer<'a, W>;
    type SerializeTupleVariant = SeqSerializer<'a, W>;
    type SerializeMap = MapSerializer<'a, W>;
    type SerializeStruct = MapSerializer<'a, W>;
    type SerializeStructVariant = MapSerializer<'a, W>;

    #[inline]
    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_bool(v)
    }

    #[inline]
    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_i8(v)
    }

    #[inline]
    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_i16(v)
    }

    #[inline]
    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_i32(v)
    }

    #[inline]
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_i64(v)
    }

    #[inline]
    fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_i128(v)
    }

    #[inline]
    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_u8(v)
    }

    #[inline]
    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_u16(v)
    }

    #[inline]
    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_u32(v)
    }

    #[inline]
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_u64(v)
    }

    #[inline]
    fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_u128(v)
    }

    #[inline]
    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_f32(v)
    }

    #[inline]
    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_f64(v)
    }

    #[inline]
    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_char(v)
    }

    #[inline]
    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_str(v)
    }

    #[inline]
    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_bytes(v)
    }

    #[inline]
    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_none()
    }

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

    #[inline]
    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_unit()
    }

    #[inline]
    fn serialize_unit_struct(self, name: &'static str) -> Result<Self::Ok, Self::Error> {
        self.inner().serialize_unit_struct(name)
    }

    #[inline]
    fn serialize_unit_variant(
        self,
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.inner()
            .serialize_unit_variant(name, variant_index, variant)
    }

    #[inline]
    fn serialize_newtype_struct<T: ?Sized>(
        self,
        name: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error>
    where
        T: serde::Serialize,
    {
        self.inner().serialize_newtype_struct(name, value)
    }

    #[inline]
    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,
    {
        self.inner()
            .serialize_newtype_variant(name, variant_index, variant, value)
    }

    #[inline]
    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        CompactFormatter {}
            .begin_array(&mut self.writer)
            .map_err(Self::Error::io)?;
        Ok(SeqSerializer::new(self, len))
    }

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

    #[inline]
    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        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, Self::Error> {
        let mut fmt = CompactFormatter {};
        fmt.begin_object(&mut self.writer)
            .map_err(Self::Error::io)?;
        fmt.begin_object_key(&mut self.writer, true)
            .map_err(Self::Error::io)?;
        self.serialize_str(variant)?;
        fmt.end_object_key(&mut self.writer)
            .map_err(Self::Error::io)?;
        fmt.begin_object_value(&mut self.writer)
            .map_err(Self::Error::io)?;
        // object is finished by SerializeTupleVariant impl
        self.serialize_seq(Some(len))
    }

    #[inline]
    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        Ok(MapSerializer::new(self, len))
    }

    #[inline]
    fn serialize_struct(
        self,
        _name: &'static str,
        len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        Ok(MapSerializer::new(self, Some(len)))
    }

    #[inline]
    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        let mut fmt = CompactFormatter {};
        fmt.begin_object(&mut self.writer)
            .map_err(Self::Error::io)?;
        fmt.begin_object_key(&mut self.writer, true)
            .map_err(Self::Error::io)?;
        self.serialize_str(variant)?;
        fmt.end_object_key(&mut self.writer)
            .map_err(Self::Error::io)?;
        fmt.begin_object_value(&mut self.writer)
            .map_err(Self::Error::io)?;
        // object is finished by SerializeStructVariant impl
        self.serialize_map(Some(len))
    }
}

pub struct MapSerializer<'a, W> {
    ser: &'a mut MapOrderingSerializer<W>,
    map: BTreeMap<Vec<u8>, (usize, usize)>,
    next_entry_key: Vec<u8>,
    val_buffer: Vec<u8>,
}

impl<'a, W: std::io::Write> MapSerializer<'a, W> {
    fn new(ser: &'a mut MapOrderingSerializer<W>, _n_keys: Option<usize>) -> Self {
        Self {
            ser,
            map: BTreeMap::new(),
            next_entry_key: Vec::new(),
            val_buffer: Vec::with_capacity(128),
        }
    }

    #[inline]
    fn end_and_maybe_close_variant(self, close_variant: bool) -> Result<(), serde_json::Error> {
        let mut fmt = CompactFormatter {};
        let writer = &mut self.ser.writer;
        fmt.begin_object(writer).map_err(serde_json::Error::io)?;

        let mut first = true;

        for (key, (value_start, value_end)) in self.map.iter() {
            fmt.begin_object_key(writer, first)
                .map_err(serde_json::Error::io)?;
            writer.write_all(key).map_err(serde_json::Error::io)?;
            fmt.end_object_key(writer).map_err(serde_json::Error::io)?;

            fmt.begin_object_value(writer)
                .map_err(serde_json::Error::io)?;
            writer
                .write_all(&self.val_buffer[*value_start..*value_end])
                .map_err(serde_json::Error::io)?;
            fmt.end_object_value(writer)
                .map_err(serde_json::Error::io)?;

            first = false;
        }

        fmt.end_object(writer).map_err(serde_json::Error::io)?;

        if close_variant {
            fmt.end_object_value(&mut self.ser.writer)
                .map_err(serde_json::Error::io)?;
            fmt.end_object(&mut self.ser.writer)
                .map_err(serde_json::Error::io)?;
        }

        Ok(())
    }
}

impl<'a, W: std::io::Write> SerializeMap for MapSerializer<'a, W> {
    type Ok = ();

    type Error = serde_json::Error;

    #[inline]
    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        key.serialize(&mut MapOrderingSerializer::new(&mut self.next_entry_key))?;

        Ok(())
    }

    #[inline]
    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        let start = self.val_buffer.len();
        value.serialize(&mut MapOrderingSerializer::new(&mut self.val_buffer))?;
        let end = self.val_buffer.len();
        let key_bytes = std::mem::take(&mut self.next_entry_key);
        self.map.insert(key_bytes, (start, end));
        Ok(())
    }

    #[inline]
    fn end(self) -> Result<(), Self::Error> {
        self.end_and_maybe_close_variant(false)
    }
}

impl<'a, W: std::io::Write> SerializeStruct for MapSerializer<'a, W> {
    type Ok = ();

    type Error = serde_json::Error;

    #[inline]
    fn serialize_field<T: ?Sized>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        self.serialize_key(key)?;
        self.serialize_value(value)
    }

    #[inline]
    fn end(self) -> Result<(), Self::Error> {
        SerializeMap::end(self)
    }
}

impl<'a, W: std::io::Write> SerializeStructVariant for MapSerializer<'a, W> {
    type Ok = ();

    type Error = serde_json::Error;

    #[inline]
    fn serialize_field<T: ?Sized>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        self.serialize_key(key)?;
        self.serialize_value(value)
    }

    #[inline]
    fn end(self) -> Result<(), Self::Error> {
        self.end_and_maybe_close_variant(true)
    }
}

pub struct SeqSerializer<'a, W> {
    ser: &'a mut MapOrderingSerializer<W>,
    first: bool,
}

impl<'a, W> SeqSerializer<'a, W> {
    fn new(ser: &'a mut MapOrderingSerializer<W>, _len: Option<usize>) -> Self {
        Self { ser, first: true }
    }
}

impl<'a, W: std::io::Write> SerializeSeq for SeqSerializer<'a, W> {
    type Ok = ();

    type Error = serde_json::Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        let mut fmt = CompactFormatter {};
        fmt.begin_array_value(&mut self.ser.writer, self.first)
            .map_err(serde_json::Error::io)?;
        value.serialize(&mut *self.ser)?;
        self.first = false;
        Ok(())
    }

    #[inline]
    fn end(self) -> Result<(), Self::Error> {
        let mut fmt = CompactFormatter {};
        fmt.end_array(&mut self.ser.writer)
            .map_err(serde_json::Error::io)
    }
}

impl<'a, W: std::io::Write> SerializeTuple for SeqSerializer<'a, W> {
    type Ok = ();

    type Error = serde_json::Error;

    #[inline]
    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        SerializeSeq::serialize_element(self, value)
    }

    #[inline]
    fn end(self) -> Result<(), Self::Error> {
        SerializeSeq::end(self)
    }
}

impl<'a, W: std::io::Write> SerializeTupleStruct for SeqSerializer<'a, W> {
    type Ok = ();

    type Error = serde_json::Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        SerializeSeq::serialize_element(self, value)
    }

    #[inline]
    fn end(self) -> Result<(), Self::Error> {
        SerializeSeq::end(self)
    }
}

impl<'a, W: std::io::Write> SerializeTupleVariant for SeqSerializer<'a, W> {
    type Ok = ();

    type Error = serde_json::Error;

    #[inline]
    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
    where
        T: serde::Serialize,
    {
        SerializeSeq::serialize_element(self, value)
    }

    #[inline]
    fn end(self) -> Result<(), Self::Error> {
        let mut fmt = CompactFormatter {};
        fmt.end_array(&mut self.ser.writer)
            .map_err(Self::Error::io)?;
        fmt.end_object_value(&mut self.ser.writer)
            .map_err(Self::Error::io)?;
        fmt.end_object(&mut self.ser.writer)
            .map_err(Self::Error::io)
    }
}