nojson 0.3.11

use core::fmt::{Display, Write};

use crate::DisplayJson;

/// A formatter for JSON values that controls the layout and formatting of the output.
///
/// [`JsonFormatter`] wraps the [`core::fmt::Formatter`] and provides methods specifically designed
/// for generating well-formed JSON with customizable formatting options like indentation and spacing.
///
/// This formatter is primarily used when implementing the [`DisplayJson`] trait or when using the
/// [`json()`](crate::json) function for in-place JSON generation.
///
/// # Examples
///
/// Basic usage with the [`json()`](crate::json) function:
/// ```
/// // Generate compact JSON
/// let compact = nojson::json(|f| f.value([1, 2, 3]));
/// assert_eq!(compact.to_string(), "[1,2,3]");
///
/// // Generate pretty-printed JSON
/// let pretty = nojson::json(|f| {
///     f.set_indent_size(2);
///     f.set_spacing(true);
///     f.value([1, 2, 3])
/// });
///
/// assert_eq!(
///     format!("\n{}", pretty),
///     r#"
/// [
///   1,
///   2,
///   3
/// ]"#
/// );
/// ```
pub struct JsonFormatter<'a, 'b> {
    inner: &'a mut core::fmt::Formatter<'b>,
    level: usize,
    indent_size: usize,
    spacing: bool,
}

impl<'a, 'b> JsonFormatter<'a, 'b> {
    pub(crate) fn new(inner: &'a mut core::fmt::Formatter<'b>) -> Self {
        Self {
            inner,
            level: 0,
            indent_size: 0,
            spacing: false,
        }
    }

    /// Formats a value that implements the [`DisplayJson`] trait.
    ///
    /// This is the primary method for writing a value to the JSON output.
    ///
    /// # Examples
    ///
    /// ```
    /// let output = nojson::json(|f| f.value([1, 2, 3]));
    /// assert_eq!(output.to_string(), "[1,2,3]");
    /// ```
    pub fn value<T: DisplayJson>(&mut self, value: T) -> core::fmt::Result {
        value.fmt(self)
    }

    /// Formats a value as a JSON string with proper escaping.
    ///
    /// This method handles the necessary escaping of special characters in JSON strings,
    /// including quotes, backslashes, control characters, etc.
    ///
    /// # Examples
    ///
    /// ```
    /// let output = nojson::json(|f| f.string("Hello\nWorld"));
    /// assert_eq!(output.to_string(), r#""Hello\nWorld""#);
    /// ```
    pub fn string<T: Display>(&mut self, content: T) -> core::fmt::Result {
        write!(self.inner, "\"")?;
        {
            let mut fmt = JsonStringContentFormatter { inner: self.inner };
            write!(fmt, "{content}")?;
        }
        write!(self.inner, "\"")?;
        Ok(())
    }

    /// Creates a JSON array with the provided formatting function.
    ///
    /// This method starts a new JSON array and provides a [`JsonArrayFormatter`] to the callback
    /// function for adding elements to the array. It handles proper indentation, spacing, and
    /// brackets placement.
    ///
    /// # Examples
    ///
    /// ```
    /// let output = nojson::json(|f| {
    ///     f.array(|f| {
    ///         f.element(1)?;
    ///         f.element(2)?;
    ///         f.element(3)
    ///     })
    /// });
    /// assert_eq!(output.to_string(), "[1,2,3]");
    ///
    /// // With pretty-printing
    /// let pretty = nojson::json(|f| {
    ///     f.set_indent_size(2);
    ///     f.set_spacing(true);
    ///     f.array(|f| {
    ///         f.element(1)?;
    ///         f.element(2)?;
    ///         f.element(3)
    ///     })
    /// });
    /// ```
    pub fn array<F>(&mut self, f: F) -> core::fmt::Result
    where
        F: FnOnce(&mut JsonArrayFormatter<'a, 'b, '_>) -> core::fmt::Result,
    {
        write!(self.inner, "[")?;

        let indent_size = self.indent_size;
        let spacing = self.spacing;
        self.level += 1;
        let mut array = JsonArrayFormatter {
            fmt: self,
            empty: true,
        };
        f(&mut array)?;
        let empty = array.empty;
        self.level -= 1;
        self.indent_size = indent_size;
        self.spacing = spacing;

        if !empty {
            self.indent()?;
        }
        write!(self.inner, "]")?;

        Ok(())
    }

    /// Creates a JSON object with the provided formatting function.
    ///
    /// This method starts a new JSON object and provides a [`JsonObjectFormatter`] to the callback
    /// function for adding members to the object. It handles proper indentation, spacing, and
    /// braces placement.
    ///
    /// # Examples
    ///
    /// ```
    /// let output = nojson::json(|f| {
    ///     f.object(|f| {
    ///         f.member("name", "Alice")?;
    ///         f.member("age", 30)
    ///     })
    /// });
    /// assert_eq!(output.to_string(), r#"{"name":"Alice","age":30}"#);
    ///
    /// // With pretty-printing
    /// let pretty = nojson::json(|f| {
    ///     f.set_indent_size(2);
    ///     f.set_spacing(true);
    ///     f.object(|f| {
    ///         f.member("name", "Alice")?;
    ///         f.member("age", 30)
    ///     })
    /// });
    /// ```
    pub fn object<F>(&mut self, f: F) -> core::fmt::Result
    where
        F: FnOnce(&mut JsonObjectFormatter<'a, 'b, '_>) -> core::fmt::Result,
    {
        write!(self.inner, "{{")?;

        let indent_size = self.indent_size;
        let spacing = self.spacing;
        self.level += 1;
        let mut object = JsonObjectFormatter {
            fmt: self,
            empty: true,
        };
        f(&mut object)?;
        let empty = object.empty;
        self.level -= 1;
        self.indent_size = indent_size;
        self.spacing = spacing;

        if !empty {
            if self.indent_size > 0 {
                self.indent()?;
            } else if self.spacing {
                write!(self.inner, " ")?;
            }
        }
        write!(self.inner, "}}")?;

        Ok(())
    }

    /// Returns a mutable reference to the inner [`core::fmt::Formatter`].
    ///
    /// This method provides direct access to the wrapped formatter, which can be useful
    /// for implementing custom formatting logic for primitive types.
    ///
    /// # Note
    ///
    /// It is the responsibility of the user to ensure that the content written to the inner formatter is valid JSON.
    pub fn inner_mut(&mut self) -> &mut core::fmt::Formatter<'b> {
        self.inner
    }

    /// Returns the current indentation level.
    ///
    /// The indentation level increases when entering arrays and objects, and
    /// decreases when exiting them.
    pub fn get_level(&self) -> usize {
        self.level
    }

    /// Returns the number of spaces used for each indentation level.
    pub fn get_indent_size(&self) -> usize {
        self.indent_size
    }

    /// Sets the number of spaces used for each indentation level.
    ///
    /// Note that this setting only affects the current and higher indentation levels.
    pub fn set_indent_size(&mut self, size: usize) {
        self.indent_size = size;
    }

    /// Returnes whether inserting a space after ':', ',', and '{'.
    pub fn get_spacing(&self) -> bool {
        self.spacing
    }

    /// Sets whether inserting a space after ':', ',', and '{'.
    ///
    /// Note that this setting only affects the current and higher indentation levels.
    pub fn set_spacing(&mut self, enable: bool) {
        self.spacing = enable;
    }

    fn indent(&mut self) -> core::fmt::Result {
        if self.indent_size > 0 {
            let total = self.indent_size * self.level;
            write!(self.inner, "\n{:total$}", "", total = total)?;
        }
        Ok(())
    }
}

impl core::fmt::Debug for JsonFormatter<'_, '_> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("JsonFormatter")
            .field("level", &self.level)
            .field("indent_size", &self.indent_size)
            .field("spacing", &self.spacing)
            .finish_non_exhaustive()
    }
}

struct JsonStringContentFormatter<'a, 'b> {
    inner: &'a mut core::fmt::Formatter<'b>,
}

impl core::fmt::Write for JsonStringContentFormatter<'_, '_> {
    fn write_str(&mut self, s: &str) -> core::fmt::Result {
        let bytes = s.as_bytes();
        let mut i = 0;
        while i < bytes.len() {
            let skip = crate::swar::skip_plain_ascii_bytes(&bytes[i..]);
            if skip > 0 {
                self.inner.write_str(&s[i..i + skip])?;
                i += skip;
                continue;
            }
            // Non-ASCII bytes don't need escaping in JSON; emit the entire
            // contiguous non-ASCII run in one write_str rather than
            // re-decoding char-by-char. Safe because `s` is valid UTF-8 and
            // `skip_non_ascii_bytes` stops at the next ASCII byte, which is
            // also a UTF-8 boundary.
            if bytes[i] >= 0x80 {
                let run = crate::swar::skip_non_ascii_bytes(&bytes[i..]);
                self.inner.write_str(&s[i..i + run])?;
                i += run;
                continue;
            }
            // ASCII byte that needs escaping: ", \, or a control character.
            let b = bytes[i];
            match b {
                b'"' => self.inner.write_str("\\\"")?,
                b'\\' => self.inner.write_str("\\\\")?,
                b'\n' => self.inner.write_str("\\n")?,
                b'\r' => self.inner.write_str("\\r")?,
                b'\t' => self.inner.write_str("\\t")?,
                0x08 => self.inner.write_str("\\b")?,
                0x0C => self.inner.write_str("\\f")?,
                _ => write!(self.inner, "\\u{:04x}", b as u32)?,
            }
            i += 1;
        }
        Ok(())
    }
}

/// A formatter for JSON arrays.
///
/// This struct is created by the [`JsonFormatter::array()`] method and provides
/// methods for adding elements to a JSON array with proper formatting, spacing,
/// and indentation.
///
/// # Examples
///
/// ```
/// let output = nojson::json(|f| {
///     f.array(|f| {
///         f.element(1)?;
///         f.element("test")?;
///         f.element(true)
///     })
/// });
/// assert_eq!(output.to_string(), r#"[1,"test",true]"#);
///
/// // With pretty-printing
/// let pretty = nojson::json(|f| {
///     f.set_indent_size(2);
///     f.set_spacing(true);
///     f.array(|f| {
///         f.elements([1, 2, 3])
///     })
/// });
/// ```
pub struct JsonArrayFormatter<'a, 'b, 'c> {
    fmt: &'c mut JsonFormatter<'a, 'b>,
    empty: bool,
}

impl JsonArrayFormatter<'_, '_, '_> {
    /// Adds a single element to the JSON array.
    ///
    /// This method handles adding the appropriate comma separators between elements
    /// and applies the current formatting rules like indentation and spacing.
    ///
    /// # Examples
    ///
    /// ```
    /// let output = nojson::json(|f| {
    ///     f.array(|f| {
    ///         f.element(1)?;
    ///         f.element("text")?;
    ///         f.element([9.87])
    ///     })
    /// });
    /// ```
    pub fn element<T: DisplayJson>(&mut self, element: T) -> core::fmt::Result {
        if !self.empty {
            write!(self.fmt.inner, ",")?;
            if self.fmt.spacing && self.fmt.indent_size == 0 {
                write!(self.fmt.inner, " ")?;
            }
        }
        self.fmt.indent()?;
        self.fmt.value(element)?;
        self.empty = false;
        Ok(())
    }

    /// Adds multiple elements to the JSON array from an iterator.
    ///
    /// This is a convenience method that iterates over the provided collection and
    /// adds each item as an element using the [`JsonArrayFormatter::element()`] method.
    ///
    /// # Examples
    ///
    /// ```
    /// let values = vec![1, 2, 3];
    /// let output = nojson::json(|f| {
    ///     f.array(|f| f.elements(&values))
    /// });
    /// assert_eq!(output.to_string(), "[1,2,3]");
    ///
    /// // Works with any iterable collection
    /// let output = nojson::json(|f| {
    ///     f.array(|f| f.elements([true, false, true]))
    /// });
    /// ```
    pub fn elements<I>(&mut self, elements: I) -> core::fmt::Result
    where
        I: IntoIterator,
        I::Item: DisplayJson,
    {
        for element in elements {
            self.element(element)?;
        }
        Ok(())
    }
}

/// A formatter for JSON objects.
///
/// This struct is created by the [`JsonFormatter::object()`] method and provides
/// methods for adding name-value pairs (members) to a JSON object with proper
/// formatting, spacing, and indentation.
///
/// # Examples
///
/// ```
/// let output = nojson::json(|f| {
///     f.object(|f| {
///         f.member("name", "Alice")?;
///         f.member("age", 30)
///     })
/// });
/// assert_eq!(output.to_string(), r#"{"name":"Alice","age":30}"#);
///
/// // With pretty-printing
/// let pretty = nojson::json(|f| {
///     f.set_indent_size(2);
///     f.set_spacing(true);
///     f.object(|f| {
///         f.member("name", "Alice")?;
///         f.member("age", 30)
///     })
/// });
/// ```
pub struct JsonObjectFormatter<'a, 'b, 'c> {
    fmt: &'c mut JsonFormatter<'a, 'b>,
    empty: bool,
}

impl JsonObjectFormatter<'_, '_, '_> {
    /// Adds a single name-value pair (member) to the JSON object.
    ///
    /// This method handles adding the appropriate comma separators between members
    /// and applies the current formatting rules like indentation and spacing.
    ///
    /// # Examples
    ///
    /// ```
    /// let output = nojson::json(|f| {
    ///     f.object(|f| {
    ///         f.member("name", "Alice")?;
    ///         f.member("age", 30)?;
    ///         f.member("active", true)
    ///     })
    /// });
    /// ```
    pub fn member<N, V>(&mut self, name: N, value: V) -> core::fmt::Result
    where
        N: Display,
        V: DisplayJson,
    {
        if !self.empty {
            write!(self.fmt.inner, ",")?;
            if self.fmt.spacing && self.fmt.indent_size == 0 {
                write!(self.fmt.inner, " ")?;
            }
        } else if self.fmt.spacing && self.fmt.indent_size == 0 {
            write!(self.fmt.inner, " ")?;
        }

        self.fmt.indent()?;
        self.fmt.string(name)?;
        write!(self.fmt.inner, ":")?;
        if self.fmt.spacing {
            write!(self.fmt.inner, " ")?;
        }
        self.fmt.value(value)?;
        self.empty = false;
        Ok(())
    }

    /// Adds multiple name-value pairs (members) to the JSON object from an iterator.
    ///
    /// This is a convenience method that iterates over the provided collection and
    /// adds each item as a member using the [`JsonObjectFormatter::member()`] method.
    ///
    /// # Examples
    ///
    /// ```
    /// use std::collections::BTreeMap;
    ///
    /// let mut map = BTreeMap::new();
    /// map.insert("name", "Alice");
    /// map.insert("age", "30");
    ///
    /// let output = nojson::json(|f| {
    ///     f.object(|f| f.members(&map))
    /// });
    /// ```
    pub fn members<I, N, V>(&mut self, members: I) -> core::fmt::Result
    where
        I: IntoIterator<Item = (N, V)>,
        N: Display,
        V: DisplayJson,
    {
        for (name, value) in members {
            self.member(name, value)?;
        }
        Ok(())
    }
}