fast-yaml-core 0.6.4

//! Generic streaming formatter with pluggable backend.
//!
//! This module contains the core formatting logic abstracted over
//! different memory allocation strategies via the `FormatterBackend` trait.

use std::borrow::Cow;
use std::fmt::Write;

use saphyr_parser::{Event, ScalarStyle, Span, Tag};

use super::traits::{AnchorStoreOps, ContextStackOps, FormatterBackend};
use super::{Context, INDENT_SPACES, MAX_ANCHOR_ID, MAX_DEPTH};
use crate::emitter::EmitterConfig;

/// Return the YAML chomp indicator suffix for a block scalar value.
///
/// - `"+"` (keep) if `value` ends with two or more newlines (trailing blank lines)
/// - `""` (clip, default) if `value` ends with exactly one newline
/// - `"-"` (strip) if `value` does not end with a newline
fn chomp_indicator(value: &str) -> &'static str {
    if value.ends_with("\n\n") {
        "+"
    } else if value.ends_with('\n') {
        ""
    } else {
        "-"
    }
}

/// Generic streaming formatter with pluggable backend.
///
/// This struct contains ALL formatting logic and is parameterized over
/// the backend type `B: FormatterBackend`. Through monomorphization,
/// this compiles to specialized code for each backend with zero runtime cost.
#[allow(clippy::struct_excessive_bools)]
pub struct StreamingFormatter<'a, B: FormatterBackend> {
    config: &'a EmitterConfig,
    output: String,
    indent_level: usize,
    /// Tracks whether we need to emit a newline before the next value
    pending_newline: bool,
    /// Tracks whether the last character written was a newline.
    /// Avoids O(n) `ends_with` scans by maintaining state.
    last_char_newline: bool,
    /// Space after mapping key colon is deferred until the value is known.
    /// Cleared without emitting when the value is a nested collection.
    pending_space: bool,
    /// The first key of a mapping opened inline after "- " must not call
    /// `write_indent` — the dash already placed the cursor at the right column.
    first_key_after_dash: bool,
    /// The first item of a sequence opened inline after an outer "- " must not
    /// call `write_indent` — the outer dash already positioned the cursor.
    first_item_after_dash: bool,
    /// Backend providing context stack and anchor storage
    backend: B,
}

impl<'a, B: FormatterBackend> StreamingFormatter<'a, B> {
    /// Creates a new formatter with the given configuration and backend.
    ///
    /// # Arguments
    ///
    /// * `config` - Emitter configuration (indent, `explicit_start`, etc.)
    /// * `output_capacity` - Initial capacity for output buffer
    /// * `backend` - Backend providing context stack and anchor storage
    pub fn new(config: &'a EmitterConfig, output_capacity: usize, backend: B) -> Self {
        Self {
            config,
            output: String::with_capacity(output_capacity),
            indent_level: 0,
            pending_newline: false,
            last_char_newline: true, // Empty buffer conceptually "ends with" newline
            pending_space: false,
            first_key_after_dash: false,
            first_item_after_dash: false,
            backend,
        }
    }

    /// Returns the current YAML structure context.
    ///
    /// # Invariant
    /// The context stack is initialized with `Context::Root` and is never
    /// fully emptied. The `unwrap_or` is a defensive fallback.
    fn current_context(&self) -> Context {
        *self
            .backend
            .context_stack()
            .last()
            .unwrap_or(&Context::Root)
    }

    /// Emits an anchor marker (&anchorN) if `anchor_id` is valid.
    ///
    /// # Arguments
    ///
    /// * `anchor_id` - The anchor ID to emit (must be in range `1..=MAX_ANCHOR_ID`)
    /// * `emit_newline` - If true, emits newline after anchor; if false, emits space
    ///
    /// # Returns
    ///
    /// Returns true if an anchor was emitted, false otherwise.
    fn emit_anchor_if_present(&mut self, anchor_id: usize, emit_newline: bool) -> bool {
        if anchor_id > 0 && anchor_id <= MAX_ANCHOR_ID {
            self.backend.anchor_store_mut().ensure_capacity(anchor_id);
            let name = self.backend.anchor_store_mut().set_if_empty(anchor_id);
            self.output.push('&');
            self.output.push_str(name);
            if emit_newline {
                self.output.push('\n');
                self.last_char_newline = true;
            } else {
                self.output.push(' ');
                self.last_char_newline = false;
            }
            true
        } else {
            false
        }
    }

    /// Processes a parser event and updates formatter state.
    pub fn format_event(&mut self, event: Event<'_>, _span: Span) {
        match event {
            Event::DocumentStart(explicit) => {
                if explicit || self.config.explicit_start {
                    self.output.push_str("---");
                    self.pending_newline = true;
                    self.last_char_newline = false;
                }
            }

            Event::DocumentEnd => {
                if !self.last_char_newline && !self.output.is_empty() {
                    self.output.push('\n');
                    self.last_char_newline = true;
                }
            }

            Event::Scalar(value, style, anchor_id, tag) => {
                self.emit_scalar(&value, style, anchor_id, tag.as_ref());
            }

            Event::SequenceStart(anchor_id, tag) => {
                self.start_sequence(anchor_id, tag.as_ref());
            }

            Event::SequenceEnd => {
                self.end_sequence();
            }

            Event::MappingStart(anchor_id, tag) => {
                self.start_mapping(anchor_id, tag.as_ref());
            }

            Event::MappingEnd => {
                self.end_mapping();
            }

            Event::Alias(anchor_id) => {
                self.emit_alias(anchor_id);
            }

            // Events that require no action
            Event::StreamStart | Event::StreamEnd | Event::Nothing => {}
        }
    }

    fn emit_scalar(
        &mut self,
        value: &str,
        style: ScalarStyle,
        anchor_id: usize,
        _tag: Option<&Cow<'_, Tag>>,
    ) {
        let ctx = self.current_context();

        // Handle pending newline from document start or collection start
        if self.pending_newline {
            self.output.push('\n');
            self.pending_newline = false;
            self.last_char_newline = true;
        }

        // Write indentation and prefix based on context
        match ctx {
            Context::Sequence => {
                if self.first_item_after_dash {
                    self.first_item_after_dash = false;
                } else {
                    self.write_indent();
                }
                self.output.push_str("- ");
                self.last_char_newline = false;
            }
            Context::MappingKey => {
                if self.first_key_after_dash {
                    self.first_key_after_dash = false;
                } else {
                    self.write_indent();
                }
            }
            // Root level scalar needs no prefix; mapping value emits pending space
            Context::Root => {}
            Context::MappingValue => {
                if self.pending_space {
                    self.output.push(' ');
                    self.pending_space = false;
                    self.last_char_newline = false;
                }
            }
        }

        // Handle anchor if present (with bounds check for security)
        self.emit_anchor_if_present(anchor_id, false);

        // Emit value with appropriate style
        self.emit_value_with_style(value, style);

        // Handle context transitions
        match ctx {
            Context::MappingKey => {
                self.output.push(':');
                // Transition to expecting value
                if let Some(last) = self.backend.context_stack_mut().last_mut() {
                    *last = Context::MappingValue;
                }
                // Defer the space — emitted only when the value is a scalar.
                // If the value is a nested collection, pending_space is cleared
                // without emitting so we avoid a trailing space before the newline.
                self.pending_space = true;
                self.last_char_newline = false;
            }
            Context::MappingValue => {
                self.output.push('\n');
                self.last_char_newline = true;
                // Transition back to expecting key
                if let Some(last) = self.backend.context_stack_mut().last_mut() {
                    *last = Context::MappingKey;
                }
            }
            Context::Sequence | Context::Root => {
                self.output.push('\n');
                self.last_char_newline = true;
            }
        }
    }

    fn emit_value_with_style(&mut self, value: &str, style: ScalarStyle) {
        match style {
            ScalarStyle::Plain => {
                // Fix special floats for YAML 1.2 compliance
                let fixed = super::fix_special_float_value(value);
                self.output.push_str(fixed);
                self.last_char_newline = false;
            }
            ScalarStyle::SingleQuoted => {
                self.output.push('\'');
                // Single quotes: escape single quotes by doubling
                for c in value.chars() {
                    if c == '\'' {
                        self.output.push_str("''");
                    } else {
                        self.output.push(c);
                    }
                }
                self.output.push('\'');
                self.last_char_newline = false;
            }
            ScalarStyle::DoubleQuoted => {
                self.output.push('"');
                // Double quotes: escape special characters
                for c in value.chars() {
                    match c {
                        '"' => self.output.push_str("\\\""),
                        '\\' => self.output.push_str("\\\\"),
                        '\n' => self.output.push_str("\\n"),
                        '\r' => self.output.push_str("\\r"),
                        '\t' => self.output.push_str("\\t"),
                        '\0' => self.output.push_str("\\0"),
                        _ => self.output.push(c),
                    }
                }
                self.output.push('"');
                self.last_char_newline = false;
            }
            ScalarStyle::Literal => {
                self.output.push('|');
                self.output.push_str(chomp_indicator(value));
                self.output.push('\n');
                self.write_block_scalar_lines(value);
                // write_block_scalar_lines always ends with newline
                self.last_char_newline = true;
            }
            ScalarStyle::Folded => {
                self.output.push('>');
                self.output.push_str(chomp_indicator(value));
                self.output.push('\n');
                self.write_block_scalar_lines(value);
                // write_block_scalar_lines always ends with newline
                self.last_char_newline = true;
            }
        }
    }

    fn start_sequence(&mut self, anchor_id: usize, _tag: Option<&Cow<'_, Tag>>) {
        let ctx = self.current_context();

        // Handle pending newline
        if self.pending_newline {
            self.output.push('\n');
            self.pending_newline = false;
            self.last_char_newline = true;
        }

        // Write prefix and anchor inline per context to avoid anchors on wrong line.
        match ctx {
            Context::Sequence => {
                if self.first_item_after_dash {
                    self.first_item_after_dash = false;
                } else {
                    self.write_indent();
                }
                self.output.push_str("- ");
                self.last_char_newline = false;
                if anchor_id > 0 && anchor_id <= MAX_ANCHOR_ID {
                    // Emit anchor inline after "- "; then a newline.
                    // Children need fresh indentation — do NOT set first_item_after_dash.
                    self.backend.anchor_store_mut().ensure_capacity(anchor_id);
                    let name = self.backend.anchor_store_mut().set_if_empty(anchor_id);
                    self.output.push('&');
                    self.output.push_str(name);
                    self.output.push('\n');
                    self.last_char_newline = true;
                } else {
                    // No anchor: first child sits right after "- ".
                    self.first_item_after_dash = true;
                }
            }
            Context::MappingKey => {
                // Sequence as mapping key - unusual but valid
                self.write_indent();
                self.emit_anchor_if_present(anchor_id, false);
            }
            Context::MappingValue => {
                // Value position - emit anchor inline if present, then newline.
                // The pending_space after colon is consumed here: if an anchor is present,
                // emit "key: &anchor\n"; otherwise emit "key:\n" (no trailing space).
                self.pending_space = false;
                if anchor_id > 0 && anchor_id <= MAX_ANCHOR_ID {
                    self.output.push(' ');
                    self.backend.anchor_store_mut().ensure_capacity(anchor_id);
                    let name = self.backend.anchor_store_mut().set_if_empty(anchor_id);
                    self.output.push('&');
                    self.output.push_str(name);
                }
                self.output.push('\n');
                self.last_char_newline = true;
            }
            Context::Root => {
                if anchor_id > 0 && anchor_id <= MAX_ANCHOR_ID {
                    self.backend.anchor_store_mut().ensure_capacity(anchor_id);
                    let name = self.backend.anchor_store_mut().set_if_empty(anchor_id);
                    self.output.push('&');
                    self.output.push_str(name);
                    self.output.push('\n');
                    self.last_char_newline = true;
                }
            }
        }

        // Update context for mapping value -> key transition
        if ctx == Context::MappingValue
            && let Some(last) = self.backend.context_stack_mut().last_mut()
        {
            *last = Context::MappingKey;
        }

        // Push sequence context and increase indent (with depth limit)
        if self.backend.context_stack().len() < MAX_DEPTH {
            self.backend.context_stack_mut().push(Context::Sequence);
            self.indent_level += 1;
        }
    }

    fn end_sequence(&mut self) {
        self.backend.context_stack_mut().pop();
        self.indent_level = self.indent_level.saturating_sub(1);
    }

    fn start_mapping(&mut self, anchor_id: usize, _tag: Option<&Cow<'_, Tag>>) {
        let ctx = self.current_context();

        // Handle pending newline
        if self.pending_newline {
            self.output.push('\n');
            self.pending_newline = false;
            self.last_char_newline = true;
        }

        // Write prefix and anchor inline per context to avoid anchors on wrong line.
        match ctx {
            Context::Sequence => {
                if self.first_item_after_dash {
                    self.first_item_after_dash = false;
                } else {
                    self.write_indent();
                }
                self.output.push_str("- ");
                self.last_char_newline = false;
                if anchor_id > 0 && anchor_id <= MAX_ANCHOR_ID {
                    // Emit anchor inline after "- "; then a newline.
                    // Anchor occupies the "- " line, so the first key goes on its own
                    // indented line — do NOT set first_key_after_dash.
                    self.backend.anchor_store_mut().ensure_capacity(anchor_id);
                    let name = self.backend.anchor_store_mut().set_if_empty(anchor_id);
                    self.output.push('&');
                    self.output.push_str(name);
                    self.output.push('\n');
                    self.last_char_newline = true;
                    self.first_key_after_dash = false;
                } else {
                    // No anchor: first key sits right after "- "; no extra indent.
                    self.first_key_after_dash = true;
                }
            }
            Context::MappingKey => {
                // Mapping as mapping key - unusual but valid (complex key)
                self.write_indent();
                self.emit_anchor_if_present(anchor_id, false);
            }
            Context::MappingValue => {
                // Value position - emit anchor inline if present, then newline.
                // The pending_space after colon is consumed here: if an anchor is present,
                // emit "key: &anchor\n"; otherwise emit "key:\n" (no trailing space).
                self.pending_space = false;
                if anchor_id > 0 && anchor_id <= MAX_ANCHOR_ID {
                    self.output.push(' ');
                    self.backend.anchor_store_mut().ensure_capacity(anchor_id);
                    let name = self.backend.anchor_store_mut().set_if_empty(anchor_id);
                    self.output.push('&');
                    self.output.push_str(name);
                }
                self.output.push('\n');
                self.last_char_newline = true;
            }
            Context::Root => {
                if anchor_id > 0 && anchor_id <= MAX_ANCHOR_ID {
                    self.backend.anchor_store_mut().ensure_capacity(anchor_id);
                    let name = self.backend.anchor_store_mut().set_if_empty(anchor_id);
                    self.output.push('&');
                    self.output.push_str(name);
                    self.output.push('\n');
                    self.last_char_newline = true;
                }
            }
        }

        // Update context for mapping value -> key transition
        if ctx == Context::MappingValue
            && let Some(last) = self.backend.context_stack_mut().last_mut()
        {
            *last = Context::MappingKey;
        }

        // Push mapping context and increase indent (with depth limit)
        if self.backend.context_stack().len() < MAX_DEPTH {
            self.backend.context_stack_mut().push(Context::MappingKey);
            self.indent_level += 1;
        }
    }

    fn end_mapping(&mut self) {
        self.backend.context_stack_mut().pop();
        self.indent_level = self.indent_level.saturating_sub(1);
    }

    fn emit_alias(&mut self, anchor_id: usize) {
        let ctx = self.current_context();

        // Handle pending newline
        if self.pending_newline {
            self.output.push('\n');
            self.pending_newline = false;
            self.last_char_newline = true;
        }

        // Write prefix based on context
        match ctx {
            Context::Sequence => {
                if self.first_item_after_dash {
                    self.first_item_after_dash = false;
                } else {
                    self.write_indent();
                }
                self.output.push_str("- ");
                self.last_char_newline = false;
            }
            Context::MappingKey => {
                self.write_indent();
            }
            Context::Root => {}
            Context::MappingValue => {
                if self.pending_space {
                    self.output.push(' ');
                    self.pending_space = false;
                    self.last_char_newline = false;
                }
            }
        }

        // Emit the alias reference
        self.output.push('*');
        if let Some(name) = self.backend.anchor_store().get(anchor_id) {
            self.output.push_str(name);
        } else {
            // Fallback: generate name directly into output
            let _ = write!(self.output, "anchor{anchor_id}");
        }
        self.last_char_newline = false;

        // Handle context transitions
        match ctx {
            Context::MappingKey => {
                self.output.push(':');
                if let Some(last) = self.backend.context_stack_mut().last_mut() {
                    *last = Context::MappingValue;
                }
                self.pending_space = true;
                // last_char_newline remains false
            }
            Context::MappingValue => {
                self.output.push('\n');
                self.last_char_newline = true;
                if let Some(last) = self.backend.context_stack_mut().last_mut() {
                    *last = Context::MappingKey;
                }
            }
            Context::Sequence | Context::Root => {
                self.output.push('\n');
                self.last_char_newline = true;
            }
        }
    }

    /// Derive YAML block scalar chomp indicator from content.
    ///
    /// - `"+"` (keep): value ends with two or more newlines
    /// - `"-"` (strip): value does not end with a newline
    /// - `""` (clip): value ends with exactly one newline
    fn chomp_indicator(value: &str) -> &'static str {
        if value.ends_with("\n\n") {
            "+"
        } else if !value.ends_with('\n') {
            "-"
        } else {
            ""
        }
    }

    /// Write indentation for block scalar content (literal/folded styles).
    ///
    /// Empty lines are emitted as bare `\n` (no trailing spaces) to match
    /// the non-streaming path in `emitter.rs`.
    fn write_block_scalar_lines(&mut self, value: &str) {
        let indent_chars = self.indent_level.saturating_mul(self.config.indent);

        // Track the last non-empty line position to handle keep (+) chomp.
        // value.lines() drops trailing empty entries produced by trailing newlines.
        let last_non_empty = value.trim_end_matches('\n');

        for line in value.lines() {
            // Blank lines inside block scalars must not receive indentation — that
            // would create trailing whitespace, which is a lint violation.
            if !line.is_empty() {
                if indent_chars <= INDENT_SPACES.len() {
                    self.output.push_str(&INDENT_SPACES[..indent_chars]);
                } else {
                    self.output.push_str(&" ".repeat(indent_chars));
                }
                self.output.push_str(line);
            }
            self.output.push('\n');
        }

        // For keep (+) chomp: value.lines() drops trailing empty entries.
        // After the last non-empty line, emit the extra blank lines that lines() skipped.
        // Example: "text\n\n" → lines() yields ["text"], but we need "text\n\n".
        // The loop above already emitted one \n after the last content line,
        // so we emit (trailing_count - 1) additional newlines.
        if value.ends_with("\n\n") {
            let trailing_count = value.len() - last_non_empty.len();
            for _ in 1..trailing_count {
                self.output.push('\n');
            }
        }
    }

    fn write_indent(&mut self) {
        if self.indent_level > 1 {
            let indent_chars = (self.indent_level - 1).saturating_mul(self.config.indent);

            if indent_chars <= INDENT_SPACES.len() {
                self.output.push_str(&INDENT_SPACES[..indent_chars]);
            } else {
                self.output.push_str(&" ".repeat(indent_chars));
            }
            self.last_char_newline = false;
        }
    }

    /// Completes formatting and returns the output string.
    pub fn finish(mut self) -> String {
        // Ensure output ends with newline
        if !self.output.is_empty() && !self.last_char_newline {
            self.output.push('\n');
        }
        self.output
    }
}