use serde::ser::{self, Serialize};
use std::fmt;

use crate::{KdlDocument, KdlEntry, KdlEntryFormat, KdlNode, KdlValue};

/// Errors that can occur during KDL serialization.
#[derive(Debug)]
pub struct Error {
    msg: String,
}

impl fmt::Display for Error {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", self.msg)
    }
}

impl std::error::Error for Error {}

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

/// Serialize a value to a KDL string.
///
/// # Example
///
/// ```rust
/// use serde::Serialize;
///
/// #[derive(Serialize)]
/// struct Config {
///     name: String,
///     port: u16,
/// }
///
/// let config = Config { name: "my-app".into(), port: 8080 };
/// let kdl = kdl::se::to_string(&config).unwrap();
/// assert_eq!(kdl, "name \"my-app\"\nport 8080\n");
/// ```
pub fn to_string<T: Serialize>(value: &T) -> Result<String, Error> {
    let doc = to_document(value)?;
    Ok(doc.to_string())
}

/// Serialize a value to a [`KdlDocument`].
///
/// This is useful if you want to manipulate the document before converting
/// it to a string.
pub fn to_document<T: Serialize>(value: &T) -> Result<KdlDocument, Error> {
    let mut ser = DocumentSerializer {
        doc: KdlDocument::new(),
    };
    value.serialize(&mut ser)?;
    Ok(ser.doc)
}

struct DocumentSerializer {
    doc: KdlDocument,
}

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

    type SerializeSeq = SeqNodeSerializer<'a>;
    type SerializeTuple = SeqNodeSerializer<'a>;
    type SerializeTupleStruct = SeqNodeSerializer<'a>;
    type SerializeTupleVariant = SeqNodeSerializer<'a>;
    type SerializeMap = MapNodeSerializer<'a>;
    type SerializeStruct = MapNodeSerializer<'a>;
    type SerializeStructVariant = StructVariantSerializer<'a>;

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        self.doc.nodes_mut().push(value_node("-", v.into()));
        Ok(())
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(v as i64)
    }
    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(v as i64)
    }
    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(v as i64)
    }
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        self.doc
            .nodes_mut()
            .push(value_node("-", KdlValue::Integer(v as i128)));
        Ok(())
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(v as u64)
    }
    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(v as u64)
    }
    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(v as u64)
    }
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        self.doc
            .nodes_mut()
            .push(value_node("-", KdlValue::Integer(v as i128)));
        Ok(())
    }

    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        self.serialize_f64(v as f64)
    }
    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        self.doc
            .nodes_mut()
            .push(value_node("-", KdlValue::Float(v)));
        Ok(())
    }

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

    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        let mut entry = KdlEntry::new(KdlValue::String(v.to_string()));
        entry.set_format(KdlEntryFormat {
            value_repr: format!("\"{}\"", v.escape_default()),
            leading: " ".to_string(),
            ..Default::default()
        });
        let mut node = KdlNode::new("-");
        node.entries_mut().push(entry);
        self.doc.nodes_mut().push(node);
        Ok(())
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        use serde::ser::SerializeSeq;
        let mut seq = self.serialize_seq(Some(v.len()))?;
        for b in v {
            seq.serialize_element(b)?;
        }
        seq.end()
    }

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

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

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        // Empty document for unit
        Ok(())
    }

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

    fn serialize_unit_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
    ) -> Result<Self::Ok, Self::Error> {
        self.doc
            .nodes_mut()
            .push(value_node("-", KdlValue::String(variant.to_string())));
        Ok(())
    }

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

    fn serialize_newtype_variant<T: ?Sized + Serialize>(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        let mut node = KdlNode::new(variant);
        let kdl_val = to_kdl_value(value)?;
        node.entries_mut().push(KdlEntry::new(kdl_val));
        self.doc.nodes_mut().push(node);
        Ok(())
    }

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Ok(SeqNodeSerializer {
            nodes: &mut self.doc.nodes,
            node_name: "-",
        })
    }

    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_seq(Some(len))
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Ok(SeqNodeSerializer {
            nodes: &mut self.doc.nodes,
            node_name: variant,
        })
    }

    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        Ok(MapNodeSerializer {
            nodes: &mut self.doc.nodes,
            current_key: None,
        })
    }

    fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        Ok(MapNodeSerializer {
            nodes: &mut self.doc.nodes,
            current_key: None,
        })
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        Ok(StructVariantSerializer {
            parent_nodes: &mut self.doc.nodes,
            variant,
            children: KdlDocument::new(),
        })
    }
}

struct SeqNodeSerializer<'a> {
    nodes: &'a mut Vec<KdlNode>,
    node_name: &'a str,
}

impl<'a> ser::SerializeSeq for SeqNodeSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
        let mut node = KdlNode::new(self.node_name);
        serialize_value_into_node(&mut node, value)?;
        self.nodes.push(node);
        Ok(())
    }

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

impl<'a> ser::SerializeTuple for SeqNodeSerializer<'a> {
    type Ok = ();
    type Error = Error;

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

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

impl<'a> ser::SerializeTupleStruct for SeqNodeSerializer<'a> {
    type Ok = ();
    type Error = Error;

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

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

impl<'a> ser::SerializeTupleVariant for SeqNodeSerializer<'a> {
    type Ok = ();
    type Error = Error;

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

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

struct MapNodeSerializer<'a> {
    nodes: &'a mut Vec<KdlNode>,
    current_key: Option<String>,
}

impl<'a> ser::SerializeMap for MapNodeSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
        self.current_key = Some(key_to_string(key)?);
        Ok(())
    }

    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
        let key = self
            .current_key
            .take()
            .ok_or_else(|| ser::Error::custom("serialize_value without serialize_key"))?;
        let mut node = KdlNode::new(key);
        serialize_value_into_node(&mut node, value)?;
        self.nodes.push(node);
        Ok(())
    }

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

impl<'a> ser::SerializeStruct for MapNodeSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error> {
        let mut node = KdlNode::new(key);
        serialize_value_into_node(&mut node, value)?;
        self.nodes.push(node);
        Ok(())
    }

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

struct StructVariantSerializer<'a> {
    parent_nodes: &'a mut Vec<KdlNode>,
    variant: &'static str,
    children: KdlDocument,
}

impl<'a> ser::SerializeStructVariant for StructVariantSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error> {
        let mut node = KdlNode::new(key);
        serialize_value_into_node(&mut node, value)?;
        self.children.nodes_mut().push(node);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        let mut node = KdlNode::new(self.variant);
        node.set_children(self.children);
        self.parent_nodes.push(node);
        Ok(())
    }
}

/// Serializes a value into a node, adding it as an argument, or as children
/// if the value is complex (struct/map/seq).
fn serialize_value_into_node<T: ?Sized + Serialize>(
    node: &mut KdlNode,
    value: &T,
) -> Result<(), Error> {
    let mut ser = NodeValueSerializer { node };
    value.serialize(&mut ser)
}

/// Serializer that writes into a KdlNode.
struct NodeValueSerializer<'a> {
    node: &'a mut KdlNode,
}

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

    type SerializeSeq = NodeSeqSerializer<'a>;
    type SerializeTuple = NodeSeqSerializer<'a>;
    type SerializeTupleStruct = NodeSeqSerializer<'a>;
    type SerializeTupleVariant = NodeChildSeqSerializer<'a>;
    type SerializeMap = NodeChildMapSerializer<'a>;
    type SerializeStruct = NodeChildMapSerializer<'a>;
    type SerializeStructVariant = NodeChildStructVariantSerializer<'a>;

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        self.node.entries_mut().push(KdlEntry::new(v));
        Ok(())
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(v as i64)
    }
    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(v as i64)
    }
    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        self.serialize_i64(v as i64)
    }
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        self.node
            .entries_mut()
            .push(KdlEntry::new(KdlValue::Integer(v as i128)));
        Ok(())
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(v as u64)
    }
    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(v as u64)
    }
    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        self.serialize_u64(v as u64)
    }
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        self.node
            .entries_mut()
            .push(KdlEntry::new(KdlValue::Integer(v as i128)));
        Ok(())
    }

    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
        self.serialize_f64(v as f64)
    }
    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
        self.node
            .entries_mut()
            .push(KdlEntry::new(KdlValue::Float(v)));
        Ok(())
    }

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

    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        let mut entry = KdlEntry::new(KdlValue::String(v.to_string()));
        entry.set_format(KdlEntryFormat {
            value_repr: format!("\"{}\"", v.escape_default()),
            leading: " ".to_string(),
            ..Default::default()
        });
        self.node.entries_mut().push(entry);
        Ok(())
    }

    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
        use serde::ser::SerializeSeq;
        let mut seq = self.serialize_seq(Some(v.len()))?;
        for b in v {
            seq.serialize_element(b)?;
        }
        seq.end()
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        self.node.entries_mut().push(KdlEntry::new(KdlValue::Null));
        Ok(())
    }

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

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        self.node.entries_mut().push(KdlEntry::new(KdlValue::Null));
        Ok(())
    }

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

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

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

    fn serialize_newtype_variant<T: ?Sized + Serialize>(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        let mut child = KdlNode::new(variant);
        let kdl_val = to_kdl_value(value)?;
        child.entries_mut().push(KdlEntry::new(kdl_val));
        let children = self.node.ensure_children();
        children.nodes_mut().push(child);
        Ok(())
    }

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Ok(NodeSeqSerializer { node: self.node })
    }

    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_seq(Some(len))
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Ok(NodeChildSeqSerializer {
            parent: self.node,
            variant_name: Some(variant),
            items: Vec::new(),
        })
    }

    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        Ok(NodeChildMapSerializer {
            node: self.node,
            current_key: None,
        })
    }

    fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        Ok(NodeChildMapSerializer {
            node: self.node,
            current_key: None,
        })
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        Ok(NodeChildStructVariantSerializer {
            parent: self.node,
            variant,
            children: KdlDocument::new(),
        })
    }
}

struct NodeSeqSerializer<'a> {
    node: &'a mut KdlNode,
}

impl<'a> ser::SerializeSeq for NodeSeqSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
        let kdl_val = to_kdl_value(value)?;
        self.node.entries_mut().push(KdlEntry::new(kdl_val));
        Ok(())
    }

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

impl<'a> ser::SerializeTuple for NodeSeqSerializer<'a> {
    type Ok = ();
    type Error = Error;

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

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

impl<'a> ser::SerializeTupleStruct for NodeSeqSerializer<'a> {
    type Ok = ();
    type Error = Error;

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

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

struct NodeChildSeqSerializer<'a> {
    parent: &'a mut KdlNode,
    variant_name: Option<&'static str>,
    items: Vec<KdlValue>,
}

impl<'a> ser::SerializeTupleVariant for NodeChildSeqSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
        let kdl_val = to_kdl_value(value)?;
        self.items.push(kdl_val);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        let name = self.variant_name.unwrap_or("-");
        let mut node = KdlNode::new(name);
        for item in self.items {
            node.entries_mut().push(KdlEntry::new(item));
        }
        let children = self.parent.ensure_children();
        children.nodes_mut().push(node);
        Ok(())
    }
}

struct NodeChildMapSerializer<'a> {
    node: &'a mut KdlNode,
    current_key: Option<String>,
}

impl<'a> ser::SerializeMap for NodeChildMapSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
        self.current_key = Some(key_to_string(key)?);
        Ok(())
    }

    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
        let key = self
            .current_key
            .take()
            .ok_or_else(|| ser::Error::custom("serialize_value without serialize_key"))?;
        let mut child = KdlNode::new(key);
        let mut child_ser = NodeValueSerializer { node: &mut child };
        value.serialize(&mut child_ser)?;
        let children = self.node.ensure_children();
        children.nodes_mut().push(child);
        Ok(())
    }

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

impl<'a> ser::SerializeStruct for NodeChildMapSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error> {
        let mut child = KdlNode::new(key);
        let mut child_ser = NodeValueSerializer { node: &mut child };
        value.serialize(&mut child_ser)?;
        let children = self.node.ensure_children();
        children.nodes_mut().push(child);
        Ok(())
    }

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

struct NodeChildStructVariantSerializer<'a> {
    parent: &'a mut KdlNode,
    variant: &'static str,
    children: KdlDocument,
}

impl<'a> ser::SerializeStructVariant for NodeChildStructVariantSerializer<'a> {
    type Ok = ();
    type Error = Error;

    fn serialize_field<T: ?Sized + Serialize>(
        &mut self,
        key: &'static str,
        value: &T,
    ) -> Result<(), Self::Error> {
        let mut child = KdlNode::new(key);
        let mut child_ser = NodeValueSerializer { node: &mut child };
        value.serialize(&mut child_ser)?;
        self.children.nodes_mut().push(child);
        Ok(())
    }

    fn end(self) -> Result<Self::Ok, Self::Error> {
        let mut node = KdlNode::new(self.variant);
        node.set_children(self.children);
        let parent_children = self.parent.ensure_children();
        parent_children.nodes_mut().push(node);
        Ok(())
    }
}

/// Helper for a regular node with just a name and just an argument value
fn value_node(name: &str, value: KdlValue) -> KdlNode {
    let mut node = KdlNode::new(name);
    node.entries_mut().push(KdlEntry::new(value));
    node
}

/// Convert a serde key to a string.
fn key_to_string<T: ?Sized + Serialize>(key: &T) -> Result<String, Error> {
    key.serialize(KeySerializer)
}

/// Restricted serializer that only produces strings (for map keys / node names).
struct KeySerializer;

impl ser::Serializer for KeySerializer {
    type Ok = String;
    type Error = Error;

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

    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
        Ok(if v {
            "true".to_string()
        } else {
            "false".to_string()
        })
    }

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        Ok(v.to_string())
    }
    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        Ok(v.to_string())
    }
    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        Ok(v.to_string())
    }
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        Ok(v.to_string())
    }
    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        Ok(v.to_string())
    }
    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        Ok(v.to_string())
    }
    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        Ok(v.to_string())
    }
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        Ok(v.to_string())
    }

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

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

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

    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
        Err(ser::Error::custom("bytes cannot be used as KDL node names"))
    }

    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
        Err(ser::Error::custom("None cannot be used as a KDL node name"))
    }

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

    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
        Err(ser::Error::custom("unit cannot be used as a KDL node name"))
    }

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

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

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

    fn serialize_newtype_variant<T: ?Sized + Serialize>(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        Err(ser::Error::custom(
            "newtype variants cannot be used as KDL node names",
        ))
    }

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Err(ser::Error::custom(
            "sequences cannot be used as KDL node names",
        ))
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        Err(ser::Error::custom(
            "tuples cannot be used as KDL node names",
        ))
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        Err(ser::Error::custom(
            "tuple structs cannot be used as KDL node names",
        ))
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Err(ser::Error::custom(
            "tuple variants cannot be used as KDL node names",
        ))
    }

    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        Err(ser::Error::custom("maps cannot be used as KDL node names"))
    }

    fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        Err(ser::Error::custom(
            "structs cannot be used as KDL node names",
        ))
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        Err(ser::Error::custom(
            "struct variants cannot be used as KDL node names",
        ))
    }
}

/// Try to convert a serde-serializable value to a KdlValue.
/// Retreats a to String for complex types.
fn to_kdl_value<T: ?Sized + Serialize>(value: &T) -> Result<KdlValue, Error> {
    value.serialize(KdlValueSerializer)
}

/// Serializer that produces a KdlValue from a scalar.
struct KdlValueSerializer;

impl ser::Serializer for KdlValueSerializer {
    type Ok = KdlValue;
    type Error = Error;

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

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

    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::Integer(v as i128))
    }
    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::Integer(v as i128))
    }
    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::Integer(v as i128))
    }
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::Integer(v as i128))
    }

    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::Integer(v as i128))
    }
    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::Integer(v as i128))
    }
    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::Integer(v as i128))
    }
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::Integer(v as i128))
    }

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

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

    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
        Ok(KdlValue::String(v.to_string()))
    }

    fn serialize_bytes(self, _v: &[u8]) -> Result<Self::Ok, Self::Error> {
        Err(ser::Error::custom(
            "bytes cannot be directly represented as a KDL value",
        ))
    }

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

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

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

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

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

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

    fn serialize_newtype_variant<T: ?Sized + Serialize>(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _value: &T,
    ) -> Result<Self::Ok, Self::Error> {
        Err(ser::Error::custom(
            "newtype variants cannot be represented as a single KDL value",
        ))
    }

    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
        Err(ser::Error::custom(
            "sequences cannot be represented as a single KDL value",
        ))
    }

    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
        Err(ser::Error::custom(
            "tuples cannot be represented as a single KDL value",
        ))
    }

    fn serialize_tuple_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
        Err(ser::Error::custom(
            "tuple structs cannot be represented as a single KDL value",
        ))
    }

    fn serialize_tuple_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
        Err(ser::Error::custom(
            "tuple variants cannot be represented as a single KDL value",
        ))
    }

    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
        Err(ser::Error::custom(
            "maps cannot be represented as a single KDL value",
        ))
    }

    fn serialize_struct(
        self,
        _name: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStruct, Self::Error> {
        Err(ser::Error::custom(
            "structs cannot be represented as a single KDL value",
        ))
    }

    fn serialize_struct_variant(
        self,
        _name: &'static str,
        _variant_index: u32,
        _variant: &'static str,
        _len: usize,
    ) -> Result<Self::SerializeStructVariant, Self::Error> {
        Err(ser::Error::custom(
            "struct variants cannot be represented as a single KDL value",
        ))
    }
}