module yaml

import strconv
import strings

struct Parser {
mut:
    lines           []string
    idx             int
    anchors         map[string]Any
    directives_done bool
}

fn (mut p Parser) parse() !Any {
    p.skip_ignorable()
    if p.idx >= p.lines.len {
        return null
    }
    indent := p.line_indent(p.idx)!
    if indent < 0 {
        return null
    }
    return p.parse_node(indent)
}

fn (mut p Parser) parse_node(indent int) !Any {
    p.skip_ignorable()
    if p.idx >= p.lines.len {
        return null
    }
    current_indent := p.line_indent(p.idx)!
    if current_indent < indent {
        return null
    }
    content := p.current_content()!
    if content.starts_with('-') && (content.len == 1 || content[1] == ` `) {
        return p.parse_sequence(current_indent)
    }
    if split_mapping_entry(content).ok {
        return p.parse_mapping(current_indent)
    }
    d := extract_decorators(content)
    if d.alias != '' && d.rest == '' {
        p.idx++
        return p.resolve_alias(d.alias)
    }
    if is_block_scalar(d.rest) {
        p.idx++
        return p.register_anchor(d.anchor, Any(p.parse_block_scalar(current_indent, d.rest)!))
    }
    if d.rest.starts_with('[') || d.rest.starts_with('{') {
        p.idx++
        full := p.collect_flow_continuation(d.rest)!
        return p.register_anchor(d.anchor, parse_flow_value(full)!)
    }
    p.idx++
    if d.rest.len > 0 && (d.rest[0] == `"` || d.rest[0] == `'`) {
        quoted := p.gather_quoted_continuation(d.rest)!
        return p.register_anchor(d.anchor, parse_scalar(quoted)!)
    }
    folded := p.gather_plain_continuation(d.rest, current_indent)
    return p.register_anchor(d.anchor, parse_scalar(folded)!)
}

// gather_plain_continuation extends a plain scalar with subsequent lines that
// belong to the same node per YAML 1.2 §6.5.1: adjacent non-blank lines fold
// to a single space, blank lines contribute literal `\n`s. The scan stops at
// document markers, structural indicators, or a less-indented line.
fn (mut p Parser) gather_plain_continuation(initial string, base_indent int) string {
    mut sb := strings.new_builder(initial.len * 2)
    sb.write_string(initial.trim_space())
    mut blanks := 0
    for p.idx < p.lines.len {
        line := p.lines[p.idx]
        trimmed_raw := line.trim_space()
        if trimmed_raw == '' {
            blanks++
            p.idx++
            continue
        }
        trimmed := strip_comments(line).trim_space()
        if trimmed == '' {
            blanks++
            p.idx++
            continue
        }
        if trimmed == '---' || trimmed == '...' {
            break
        }
        line_indent := p.line_indent(p.idx) or { break }
        if line_indent < base_indent {
            break
        }
        if trimmed.starts_with('- ') || trimmed == '-' {
            break
        }
        if split_mapping_entry(trimmed).ok {
            break
        }
        if blanks > 0 {
            for _ in 0 .. blanks {
                sb.write_u8(`\n`)
            }
            blanks = 0
        } else {
            sb.write_u8(` `)
        }
        sb.write_string(trimmed)
        p.idx++
    }
    return sb.str()
}

fn (mut p Parser) parse_mapping(indent int) !Any {
    mut result := map[string]Any{}
    for p.idx < p.lines.len {
        p.skip_ignorable()
        if p.idx >= p.lines.len {
            break
        }
        current_indent := p.line_indent(p.idx)!
        if current_indent < indent {
            break
        }
        if current_indent > indent {
            return error('yaml: unexpected indentation on line ${p.idx + 1}')
        }
        content := p.current_content()!
        entry := split_mapping_entry(content)
        if !entry.ok {
            return error('yaml: expected a mapping entry on line ${p.idx + 1}')
        }
        p.idx++
        result[entry.key] = p.parse_mapping_value(entry.rest, indent)!
    }
    return Any(result)
}

fn (mut p Parser) parse_mapping_value(rest_in string, indent int) !Any {
    d := extract_decorators(rest_in)
    if d.alias != '' && d.rest == '' {
        return p.resolve_alias(d.alias)
    }
    value := if d.rest == '' {
        next_indent := p.peek_next_indent()
        if next_indent > indent {
            p.parse_node(next_indent)!
        } else {
            null
        }
    } else if is_block_scalar(d.rest) {
        Any(p.parse_block_scalar(indent, d.rest)!)
    } else if d.rest.starts_with('[') || d.rest.starts_with('{') {
        full := p.collect_flow_continuation(d.rest)!
        parse_flow_value(full)!
    } else if d.rest.len > 0 && (d.rest[0] == `"` || d.rest[0] == `'`) {
        quoted := p.gather_quoted_continuation(d.rest)!
        parse_scalar(quoted)!
    } else {
        parse_scalar(d.rest)!
    }
    return p.register_anchor(d.anchor, value)
}

fn (mut p Parser) parse_sequence(indent int) !Any {
    mut items := []Any{}
    for p.idx < p.lines.len {
        p.skip_ignorable()
        if p.idx >= p.lines.len {
            break
        }
        current_indent := p.line_indent(p.idx)!
        if current_indent < indent {
            break
        }
        if current_indent > indent {
            return error('yaml: unexpected indentation on line ${p.idx + 1}')
        }
        content := p.current_content()!
        if !content.starts_with('-') || (content.len > 1 && content[1] != ` `) {
            break
        }
        rest := if content.len == 1 { '' } else { content[1..].trim_space() }
        p.idx++
        items << p.parse_sequence_item(rest, indent)!
    }
    return Any(items)
}

fn (mut p Parser) parse_sequence_item(rest_in string, indent int) !Any {
    d := extract_decorators(rest_in)
    if d.alias != '' && d.rest == '' {
        return p.resolve_alias(d.alias)
    }
    value := if d.rest == '' {
        next_indent := p.peek_next_indent()
        if next_indent > indent {
            p.parse_node(next_indent)!
        } else {
            null
        }
    } else if is_block_scalar(d.rest) {
        Any(p.parse_block_scalar(indent, d.rest)!)
    } else if d.rest.starts_with('[') || d.rest.starts_with('{') {
        full := p.collect_flow_continuation(d.rest)!
        parse_flow_value(full)!
    } else {
        entry := split_mapping_entry(d.rest)
        if entry.ok {
            mut result := map[string]Any{}
            child_indent := indent + 2
            result[entry.key] = p.parse_mapping_value(entry.rest, child_indent)!
            for p.idx < p.lines.len {
                p.skip_ignorable()
                if p.idx >= p.lines.len {
                    break
                }
                current_indent := p.line_indent(p.idx)!
                if current_indent <= indent {
                    break
                }
                if current_indent != child_indent {
                    return error('yaml: unexpected indentation on line ${p.idx + 1}')
                }
                content := p.current_content()!
                next_entry := split_mapping_entry(content)
                if !next_entry.ok {
                    break
                }
                p.idx++
                result[next_entry.key] = p.parse_mapping_value(next_entry.rest, child_indent)!
            }
            Any(result)
        } else if d.rest.len > 0 && (d.rest[0] == `"` || d.rest[0] == `'`) {
            quoted := p.gather_quoted_continuation(d.rest)!
            parse_scalar(quoted)!
        } else {
            parse_scalar(d.rest)!
        }
    }
    return p.register_anchor(d.anchor, value)
}

fn (p &Parser) resolve_alias(name string) Any {
    return p.anchors[name] or { null }
}

// register_anchor associates `value` with `anchor` when the latter is set,
// then returns `value` so call sites can `return p.register_anchor(...)`
// in a single statement instead of branching.
fn (mut p Parser) register_anchor(anchor string, value Any) Any {
    if anchor != '' {
        p.anchors[anchor] = value
    }
    return value
}

// parse_block_scalar parses a `|` (literal) or `>` (folded) block, honoring
// the optional chomp indicator from the header (`-` strip, `+` keep, default
// clip). Indent indicators (`|2`) are tolerated but ignored — the block's
// indentation is auto-detected from the first non-empty content line.
fn (mut p Parser) parse_block_scalar(parent_indent int, header string) !string {
    style, chomp := parse_block_header(header)
    start := p.idx
    mut min_indent := -1
    for i := start; i < p.lines.len; i++ {
        line := p.lines[i]
        if line.trim_space() == '' {
            continue
        }
        line_indent := p.line_indent(i)!
        if line_indent <= parent_indent {
            break
        }
        if min_indent == -1 || line_indent < min_indent {
            min_indent = line_indent
        }
    }
    if min_indent == -1 {
        // Body is entirely empty/blank. Keep chomp (`+`) still preserves the
        // implicit trailing line breaks; strip and clip yield the empty string.
        if chomp != `+` {
            return ''
        }
        mut blanks := 0
        for p.idx < p.lines.len {
            line := p.lines[p.idx]
            if line.trim_space() != '' {
                break
            }
            blanks++
            p.idx++
        }
        if blanks == 0 {
            blanks = 1
        }
        return '\n'.repeat(blanks)
    }
    mut lines := []string{}
    for p.idx < p.lines.len {
        line := p.lines[p.idx]
        if line.trim_space() == '' {
            lines << ''
            p.idx++
            continue
        }
        line_indent := p.line_indent(p.idx)!
        if line_indent <= parent_indent {
            break
        }
        if line.len <= min_indent {
            lines << ''
        } else {
            lines << line[min_indent..]
        }
        p.idx++
    }
    mut stripped_trailing := 0
    for lines.len > 0 && lines[lines.len - 1] == '' {
        stripped_trailing++
        lines.delete(lines.len - 1)
    }
    body := if style == `|` { lines.join('\n') } else { fold_block_scalar(lines) }
    return apply_chomp(body, chomp, stripped_trailing)
}

struct FlowBalance {
mut:
    bracket   int
    brace     int
    in_single bool
    in_double bool
    escape    bool
}

// collect_flow_continuation gathers subsequent lines into `initial` until the
// `[` / `{` brackets and the active quoted strings are all balanced. YAML 1.2
// allows flow collections to span lines; without this the parser would reject
// anything that wraps. The returned text is what `parse_flow_value` receives.
fn (mut p Parser) collect_flow_continuation(initial string) !string {
    mut bal := FlowBalance{}
    bal.scan(initial)
    if !bal.unbalanced() {
        return initial
    }
    mut sb := strings.new_builder(initial.len * 2)
    sb.write_string(initial)
    for p.idx < p.lines.len && bal.unbalanced() {
        line := p.lines[p.idx]
        segment := if bal.in_single || bal.in_double { line } else { strip_comments(line) }
        trimmed := segment.trim_space()
        if trimmed == '' && !bal.in_single && !bal.in_double {
            p.idx++
            continue
        }
        sb.write_u8(` `)
        sb.write_string(trimmed)
        bal.scan(trimmed)
        p.idx++
    }
    if bal.unbalanced() {
        return error('yaml: unterminated flow collection')
    }
    return sb.str()
}

fn (b &FlowBalance) unbalanced() bool {
    return b.bracket > 0 || b.brace > 0 || b.in_single || b.in_double
}

fn (mut b FlowBalance) scan(s string) {
    for i := 0; i < s.len; i++ {
        ch := s[i]
        if b.in_double {
            if b.escape {
                b.escape = false
            } else if ch == `\\` {
                b.escape = true
            } else if ch == `"` {
                b.in_double = false
            }
            continue
        }
        if b.in_single {
            if ch == `'` {
                if i + 1 < s.len && s[i + 1] == `'` {
                    i++
                    continue
                }
                b.in_single = false
            }
            continue
        }
        match ch {
            `"` { b.in_double = true }
            `'` { b.in_single = true }
            `[` { b.bracket++ }
            `]` { b.bracket-- }
            `{` { b.brace++ }
            `}` { b.brace-- }
            else {}
        }
    }
}

// parse_block_header reads the `|`/`>` style and the optional `+`/`-` chomp
// indicator from a block-scalar header like `|`, `|-`, `|+`, `>2-`.
fn parse_block_header(s string) (u8, u8) {
    if s == '' {
        return `|`, 0
    }
    style := s[0]
    mut chomp := u8(0)
    for i := 1; i < s.len; i++ {
        c := s[i]
        if c == `+` || c == `-` {
            chomp = c
        }
    }
    return style, chomp
}

// apply_chomp rewrites the block body's trailing whitespace per RFC 9.1.1.2:
// strip removes all trailing newlines, clip keeps a single trailing newline
// when the body is non-empty, keep preserves every original trailing newline.
fn apply_chomp(body string, chomp u8, stripped_trailing int) string {
    return match chomp {
        `-` {
            body
        }
        `+` {
            clipped := if body == '' { '' } else { body + '\n' }
            clipped + '\n'.repeat(stripped_trailing)
        }
        else {
            if body == '' {
                ''
            } else {
                body + '\n'
            }
        }
    }
}

// is_ignorable_line returns true when `trimmed` is content the parser must
// skip over: blank lines, document markers, and directive lines that occur
// before the first body line. Directives (`%YAML`, `%TAG`, …) become plain
// text once `directives_done` flips, so the skip is conditional on that flag.
fn (p &Parser) is_ignorable_line(trimmed string) bool {
    return trimmed == '' || trimmed == '---' || trimmed == '...'
        || (trimmed.starts_with('%') && !p.directives_done)
}

fn (mut p Parser) skip_ignorable() {
    for p.idx < p.lines.len {
        line := p.lines[p.idx]
        trimmed := strip_comments(line).trim_space()
        if p.is_ignorable_line(trimmed) {
            p.idx++
            continue
        }
        // `--- <inline>` (or `---\t…`) folds the document marker away and
        // keeps the inline content as the document body at column 0.
        if (line.starts_with('--- ') || line.starts_with('---\t')) && line.len > 4 {
            p.lines[p.idx] = line[4..]
        }
        p.directives_done = true
        break
    }
}

fn (p &Parser) peek_next_indent() int {
    mut i := p.idx
    for i < p.lines.len {
        line := p.lines[i]
        trimmed := strip_comments(line).trim_space()
        if p.is_ignorable_line(trimmed) {
            i++
            continue
        }
        return p.line_indent(i) or { -1 }
    }
    return -1
}

fn (p &Parser) current_content() !string {
    line := p.lines[p.idx]
    indent := p.line_indent(p.idx)!
    if line.len <= indent {
        return ''
    }
    return strip_comments(line[indent..]).trim_space()
}

fn (p &Parser) line_indent(index int) !int {
    line := p.lines[index]
    mut indent := 0
    for indent < line.len && line[indent] == ` ` {
        indent++
    }
    if indent < line.len && line[indent] == `\t` {
        return error('yaml: tabs are not supported for indentation on line ${index + 1}')
    }
    return indent
}

struct MappingEntry {
    key  string
    rest string
    ok   bool
}

fn split_mapping_entry(content string) MappingEntry {
    mut in_single := false
    mut in_double := false
    mut escape := false
    mut bracket_depth := 0
    mut brace_depth := 0
    mut i := 0
    for i < content.len {
        ch := content[i]
        if in_double {
            if escape {
                escape = false
            } else if ch == `\\` {
                escape = true
            } else if ch == `"` {
                in_double = false
            }
            i++
            continue
        }
        if in_single {
            if ch == `'` {
                if i + 1 < content.len && content[i + 1] == `'` {
                    i += 2
                    continue
                }
                in_single = false
            }
            i++
            continue
        }
        match ch {
            `"` {
                in_double = true
            }
            `'` {
                in_single = true
            }
            `[` {
                bracket_depth++
            }
            `]` {
                if bracket_depth > 0 {
                    bracket_depth--
                }
            }
            `{` {
                brace_depth++
            }
            `}` {
                if brace_depth > 0 {
                    brace_depth--
                }
            }
            `:` {
                if bracket_depth == 0 && brace_depth == 0
                    && (i + 1 == content.len || content[i + 1].is_space()) {
                    key_text := content[..i].trim_space()
                    if key_text == '' {
                        return MappingEntry{}
                    }
                    return MappingEntry{
                        key:  parse_key(key_text) or { return MappingEntry{} }
                        rest: if i + 1 < content.len {
                            content[i + 1..].trim_space()
                        } else {
                            ''
                        }
                        ok:   true
                    }
                }
            }
            else {}
        }

        i++
    }
    return MappingEntry{}
}

// strip_node_decorators removes a leading anchor (`&id`), a tag (`!Type` or
// `!!Type`), or a sequence of both, from a YAML node's text. The semantics of
// anchors and tags are intentionally not implemented: stripping them lets the
// underlying scalar/collection still parse, which matches the common practical
// case where the document carries decorators but does not rely on them. A
// stand-alone alias (`*name`) cannot be resolved without anchor tracking and
// is therefore left untouched, so the caller still sees that something was
// referenced.
fn strip_node_decorators(s string) string {
    return extract_decorators(s).rest
}

// Decorators carries the anchor / alias / remaining content split off a node.
struct Decorators {
    anchor string
    alias  string
    rest   string
}

// extract_decorators peels leading anchor / alias / tag decorators off `s` and
// returns the anchor name, alias name, and remaining content. At most one
// anchor and one alias are recognized; tags are stripped without being
// returned.
fn extract_decorators(s string) Decorators {
    mut anchor := ''
    mut alias := ''
    mut out := s.trim_left(' \t')
    for {
        if out.len < 2 {
            break
        }
        c := out[0]
        if (c == `&` || c == `*`) && out[1] != ` ` && out[1] != `\t` {
            mut i := 1
            for i < out.len && out[i] != ` ` && out[i] != `\t` {
                i++
            }
            name := out[1..i]
            if c == `&` {
                anchor = name
            } else {
                alias = name
            }
            out = out[i..].trim_left(' \t')
            continue
        }
        if c == `!` {
            mut i := 1
            if i < out.len && out[i] == `!` {
                i++
            }
            for i < out.len && out[i] != ` ` && out[i] != `\t` {
                i++
            }
            out = out[i..].trim_left(' \t')
            continue
        }
        break
    }
    return Decorators{
        anchor: anchor
        alias:  alias
        rest:   out
    }
}

// parse_key resolves a mapping-key token: drops anchor / tag decorators,
// unquotes the result if surrounded by matching `"` or `'` quotes, and
// returns the cleaned key string otherwise.
fn parse_key(src string) !string {
    cleaned := strip_node_decorators(src)
    if cleaned.len >= 2 && ((cleaned[0] == `"` && cleaned[cleaned.len - 1] == `"`)
        || (cleaned[0] == `'` && cleaned[cleaned.len - 1] == `'`)) {
        return parse_quoted_string(cleaned)
    }
    return cleaned.trim_space()
}

// parse_scalar resolves a scalar token to its YAML 1.2 typed value: quoted
// strings unquote, the case-insensitive keywords `null`/`~`, `true`/`yes`/`on`
// and `false`/`no`/`off` produce the matching constants, integer and float
// literals (with `_` digit separators) parse to `i64`/`u64`/`f64`, and any
// other text falls back to a plain string.
fn parse_scalar(text string) !Any {
    value := strip_node_decorators(text).trim_space()
    if value == '' {
        return Any('')
    }
    if value.len >= 2 && ((value[0] == `"` && value[value.len - 1] == `"`)
        || (value[0] == `'` && value[value.len - 1] == `'`)) {
        return Any(parse_quoted_string(value)!)
    }
    // Keyword check: only strings of length 1..5 can match `~`, `null`, `true`,
    // `yes`, `on`, `false`, `no`, `off`. Length-bound first to skip the
    // allocation of `to_lower()` for every plain scalar (the overwhelmingly
    // common case in real documents).
    if value.len <= 5 {
        if value.len == 1 && value[0] == `~` {
            return null
        }
        if equals_ascii_ci(value, 'null') {
            return null
        }
        if equals_ascii_ci(value, 'true') || equals_ascii_ci(value, 'yes')
            || equals_ascii_ci(value, 'on') {
            return Any(true)
        }
        if equals_ascii_ci(value, 'false') || equals_ascii_ci(value, 'no')
            || equals_ascii_ci(value, 'off') {
            return Any(false)
        }
    }
    numeric := strip_underscores(value)
    if is_integer(numeric) {
        if numeric.starts_with('-') {
            return Any(numeric.parse_int(0, 64)!)
        }
        if numeric.starts_with('+') {
            return Any(numeric[1..].parse_uint(0, 64)!)
        }
        return Any(numeric.parse_uint(0, 64)!)
    }
    if is_float(numeric) {
        return Any(strconv.atof64(numeric)!)
    }
    return Any(value)
}

// parse_quoted_string unquotes a YAML scalar wrapped in matching `"` or `'`
// quotes. Single-quoted strings only undouble `''` to `'`. Double-quoted
// strings honor the YAML 1.2 §5.7 escape set (`\b \f \n \r \t \" \\ \/
// \uXXXX`); any other backslash sequence is rejected as malformed.
fn parse_quoted_string(src string) !string {
    if src.len < 2 {
        return error('yaml: invalid quoted string')
    }
    quote := src[0]
    inner := fold_quoted_inner(src[1..src.len - 1])
    if quote == `'` {
        // Single-quoted strings only undouble `''`. When the body has no
        // doubled quote, return the slice as-is — `inner` already shares the
        // source buffer, so this avoids a `replace` allocation.
        if !inner.contains("''") {
            return inner
        }
        return inner.replace("''", "'")
    }
    // Double-quoted fast path: if there's no `\` in the body, no escape
    // resolution is needed — `inner` is the final value verbatim.
    if !inner.contains_u8(`\\`) {
        return inner
    }
    mut out := []u8{cap: inner.len}
    mut i := 0
    for i < inner.len {
        ch := inner[i]
        if ch != `\\` {
            out << ch
            i++
            continue
        }
        i++
        if i >= inner.len {
            return error('yaml: invalid escape sequence')
        }
        esc := inner[i]
        match esc {
            `"`, `\\`, `/` {
                out << esc
            }
            `b` {
                out << `\b`
            }
            `f` {
                out << `\f`
            }
            `n` {
                out << `\n`
            }
            `r` {
                out << `\r`
            }
            `t` {
                out << `\t`
            }
            `u` {
                if i + 4 >= inner.len {
                    return error('yaml: invalid unicode escape')
                }
                code := inner[i + 1..i + 5]
                r := rune(code.parse_uint(16, 32)!)
                out << r.str().bytes()
                i += 4
            }
            else {
                return error('yaml: unknown escape sequence \\${rune(esc).str()}')
            }
        }

        i++
    }
    return out.bytestr()
}

// fold_quoted_inner applies YAML 1.2 §7.3 line folding rules to the body of a
// quoted scalar (the chars between the opening and closing quote): adjacent
// non-blank content lines fold to a single space, runs of N consecutive line
// breaks collapse to N-1 literal newlines, and leading whitespace inside
// continuation lines is stripped. A leading or trailing empty line folds to a
// single space (§7.3.1).
fn fold_quoted_inner(inner string) string {
    if !inner.contains_u8(`\n`) {
        return inner
    }
    lines := inner.split('\n')
    n := lines.len
    mut trimmed := []string{cap: n}
    for i := 0; i < n; i++ {
        line := lines[i]
        if i == 0 && i != n - 1 {
            trimmed << line.trim_right(' \t')
        } else if i == n - 1 && i != 0 {
            trimmed << line.trim_left(' \t')
        } else {
            trimmed << line.trim(' \t')
        }
    }
    has_pre := trimmed[0] == ''
    has_post := trimmed[n - 1] == ''
    mut sb := strings.new_builder(inner.len)
    if has_pre {
        sb.write_u8(` `)
    }
    start := if has_pre { 1 } else { 0 }
    end := if has_post { n - 1 } else { n }
    mut blanks := 0
    mut wrote := false
    for i := start; i < end; i++ {
        f := trimmed[i]
        if f == '' {
            blanks++
            continue
        }
        if wrote {
            if blanks == 0 {
                sb.write_u8(` `)
            } else {
                for _ in 0 .. blanks {
                    sb.write_u8(`\n`)
                }
            }
        }
        blanks = 0
        sb.write_string(f)
        wrote = true
    }
    if has_post {
        sb.write_u8(` `)
    }
    return sb.str()
}

// quoted_terminated reports whether `s` (which starts with a `quote` byte)
// ends with the matching closing quote, taking single-quote `''` doubling and
// double-quote `\` escapes into account.
fn quoted_terminated(s string, quote u8) bool {
    if s.len < 2 || s[0] != quote {
        return false
    }
    mut i := 1
    if quote == `'` {
        for i < s.len {
            if s[i] == `'` {
                if i + 1 < s.len && s[i + 1] == `'` {
                    i += 2
                    continue
                }
                return i == s.len - 1
            }
            i++
        }
        return false
    }
    mut esc := false
    for i < s.len {
        ch := s[i]
        if esc {
            esc = false
            i++
            continue
        }
        if ch == `\\` {
            esc = true
            i++
            continue
        }
        if ch == `"` {
            return i == s.len - 1
        }
        i++
    }
    return false
}

// gather_quoted_continuation accumulates subsequent lines into a quoted scalar
// that doesn't terminate on its first line. The returned string still wraps
// the original line breaks; `fold_quoted_inner` collapses them later.
fn (mut p Parser) gather_quoted_continuation(initial string) !string {
    if initial == '' {
        return initial
    }
    quote := initial[0]
    if quote != `"` && quote != `'` {
        return initial
    }
    if quoted_terminated(initial, quote) {
        return initial
    }
    mut buf := initial.bytes()
    for p.idx < p.lines.len {
        buf << `\n`
        buf << p.lines[p.idx].bytes()
        p.idx++
        snap := buf.bytestr()
        if quoted_terminated(snap, quote) {
            return snap
        }
    }
    return error('yaml: unterminated quoted string')
}

fn strip_comments(line string) string {
    // Fast path: the overwhelming majority of YAML lines have no `#`.
    if !line.contains_u8(`#`) {
        return line.trim_right(' \t')
    }
    mut in_single := false
    mut in_double := false
    mut escape := false
    mut bracket_depth := 0
    mut brace_depth := 0
    mut i := 0
    for i < line.len {
        ch := line[i]
        if in_double {
            if escape {
                escape = false
            } else if ch == `\\` {
                escape = true
            } else if ch == `"` {
                in_double = false
            }
            i++
            continue
        }
        if in_single {
            if ch == `'` {
                if i + 1 < line.len && line[i + 1] == `'` {
                    i += 2
                    continue
                }
                in_single = false
            }
            i++
            continue
        }
        match ch {
            `"` {
                in_double = true
            }
            `'` {
                in_single = true
            }
            `[` {
                bracket_depth++
            }
            `]` {
                if bracket_depth > 0 {
                    bracket_depth--
                }
            }
            `{` {
                brace_depth++
            }
            `}` {
                if brace_depth > 0 {
                    brace_depth--
                }
            }
            `#` {
                if bracket_depth == 0 && brace_depth == 0 {
                    return line[..i].trim_right(' \t')
                }
            }
            else {}
        }

        i++
    }
    return line.trim_right(' \t')
}

fn fold_block_scalar(lines []string) string {
    mut out := ''
    mut pending_newlines := 0
    mut started := false
    for line in lines {
        if line == '' {
            pending_newlines++
            continue
        }
        if !started {
            out = '\n'.repeat(pending_newlines) + line
            started = true
        } else if pending_newlines > 0 {
            out += '\n'.repeat(pending_newlines) + line
        } else {
            out += ' ' + line
        }
        pending_newlines = 0
    }
    if pending_newlines > 0 {
        out += '\n'.repeat(pending_newlines)
    }
    return out
}

fn is_block_scalar(value string) bool {
    if value == '' || (value[0] != `|` && value[0] != `>`) {
        return false
    }
    // Allow `|`, `>`, `|-`, `|+`, `>2`, `|3-`, etc. Any other char rules it out
    // (e.g. `> something` is just a plain scalar starting with `>`).
    for i := 1; i < value.len; i++ {
        c := value[i]
        if c != `+` && c != `-` && !(c >= `0` && c <= `9`) {
            return false
        }
    }
    return true
}

fn is_integer(value string) bool {
    if value == '' {
        return false
    }
    if value[0] in [`+`, `-`] {
        if value.len == 1 {
            return false
        }
        if value[0] == `-` {
            value.parse_int(0, 64) or { return false }
            return true
        }
        value[1..].parse_uint(0, 64) or { return false }
        return true
    }
    value.parse_uint(0, 64) or { return false }
    return true
}

fn is_float(value string) bool {
    if value == '' {
        return false
    }
    if !value.contains('.') && !value.contains('e') && !value.contains('E') {
        return false
    }
    strconv.atof64(value) or { return false }
    return true
}

// equals_ascii_ci reports whether `s` equals `lower_ref` byte-for-byte once
// ASCII letters in `s` are lower-cased. `lower_ref` MUST already be lowercase
// ASCII; mixing case in it silently breaks the comparison. Used by
// `parse_scalar` to recognize boolean / null keywords without allocating a
// lower-cased copy of every plain scalar in the document.
fn equals_ascii_ci(s string, lower_ref string) bool {
    if s.len != lower_ref.len {
        return false
    }
    for i := 0; i < s.len; i++ {
        mut c := s[i]
        if c >= `A` && c <= `Z` {
            c |= 0x20
        }
        if c != lower_ref[i] {
            return false
        }
    }
    return true
}

// strip_underscores removes `_` digit separators from a numeric literal in a
// single pass. Returns `value` unchanged when no `_` is present, avoiding an
// allocation on the common case.
fn strip_underscores(value string) string {
    if !value.contains_u8(`_`) {
        return value
    }
    mut out := []u8{cap: value.len}
    for c in value {
        if c != `_` {
            out << c
        }
    }
    return out.bytestr()
}