module yaml

// Conformance-style coverage. Each case mirrors a pattern from the YAML 1.2
// spec (or the public yaml-test-suite) that's within the subset V's parser
// implements: plain mappings, sequences, scalars, flow style, JSON-superset
// documents. Anchors, aliases, tags, merge keys, multi-document streams and
// the chomp/indent indicators on block scalars are intentionally NOT covered:
// V's parser does not support them today.
//
// Each case is `name | yaml_input | expected_json` and is verified by parsing
// `yaml_input`, serializing to JSON, and comparing against the expected JSON
// via `json_logically_eq` (see `test_helpers.v`).
//
// Scalar variants (booleans, nulls, numeric underscores), quoted-string
// escapes, block scalars, `[]`/`{}`, and the empty document are exercised by
// `yaml_edge_cases_test.v` with stricter, typed assertions; not duplicated here.

struct ConformanceCase {
    name     string
    src      string
    expected string
}

const cases = [
    ConformanceCase{
        name:     'single scalar mapping'
        src:      'key: value'
        expected: '{"key":"value"}'
    },
    ConformanceCase{
        name:     'integer values'
        src:      'a: 1\nb: -2\nc: 0\nd: 9223372036854775807'
        expected: '{"a":1,"b":-2,"c":0,"d":9223372036854775807}'
    },
    ConformanceCase{
        name:     'float values'
        src:      'a: 1.5\nb: -0.001\nc: 1.0e10\nd: -1.5e-3'
        expected: '{"a":1.5,"b":-0.001,"c":10000000000,"d":-0.0015}'
    },
    ConformanceCase{
        name:     'simple sequence'
        src:      'items:\n  - one\n  - two\n  - three'
        expected: '{"items":["one","two","three"]}'
    },
    ConformanceCase{
        name:     'nested mapping under sequence item'
        src:      'servers:\n  - host: a\n    port: 1\n  - host: b\n    port: 2'
        expected: '{"servers":[{"host":"a","port":1},{"host":"b","port":2}]}'
    },
    ConformanceCase{
        name:     'flow sequence inline'
        src:      'tags: [web, api, db]'
        expected: '{"tags":["web","api","db"]}'
    },
    ConformanceCase{
        name:     'flow mapping inline'
        src:      'config: {host: a, port: 8080}'
        expected: '{"config":{"host":"a","port":8080}}'
    },
    ConformanceCase{
        name:     'mixed flow and block'
        src:      'top:\n  inner:\n    - {k: v, n: 1}\n    - [a, b, c]'
        expected: '{"top":{"inner":[{"k":"v","n":1},["a","b","c"]]}}'
    },
    ConformanceCase{
        name:     'deeply nested mapping'
        src:      'a:\n  b:\n    c:\n      d:\n        e: end'
        expected: '{"a":{"b":{"c":{"d":{"e":"end"}}}}}'
    },
    ConformanceCase{
        name:     'sequence of sequences'
        src:      'matrix:\n  - [1, 2, 3]\n  - [4, 5, 6]\n  - [7, 8, 9]'
        expected: '{"matrix":[[1,2,3],[4,5,6],[7,8,9]]}'
    },
    ConformanceCase{
        name:     'unicode in string values'
        src:      'a: "café"\nb: "日本語"\nc: plain café'
        expected: '{"a":"café","b":"日本語","c":"plain café"}'
    },
    ConformanceCase{
        name:     'comment is stripped'
        src:      '# leading comment\nkey: value # trailing comment'
        expected: '{"key":"value"}'
    },
    ConformanceCase{
        name:     'document separator markers are tolerated'
        src:      '---\na: 1\n...'
        expected: '{"a":1}'
    },
    ConformanceCase{
        name:     'JSON-superset input (object)'
        src:      '{"a": 1, "b": [2, 3]}'
        expected: '{"a":1,"b":[2,3]}'
    },
    ConformanceCase{
        name:     'JSON-superset input (array root)'
        src:      '[1, 2, {"three": 3}]'
        expected: '[1,2,{"three":3}]'
    },
    ConformanceCase{
        name:     'sequence containing null'
        src:      'a:\n  - one\n  - ~\n  - three'
        expected: '{"a":["one",null,"three"]}'
    },
    ConformanceCase{
        name:     'mapping with quoted keys containing dots'
        src:      'plain: 1\n"a.b": 2\n"c.d.e": 3'
        expected: '{"plain":1,"a.b":2,"c.d.e":3}'
    },
    ConformanceCase{
        name:     'mixed types in flow sequence'
        src:      'mix: [1, "two", true, null, 3.14]'
        expected: '{"mix":[1,"two",true,null,3.14]}'
    },
    ConformanceCase{
        name:     'nested flow inside block sequence'
        src:      'items:\n  - {a: 1, b: [x, y]}\n  - {a: 2, b: [z]}'
        expected: '{"items":[{"a":1,"b":["x","y"]},{"a":2,"b":["z"]}]}'
    },
]!

fn test_yaml_conformance_cases() ! {
    mut failed := []string{}
    for c in cases {
        doc := parse_text(c.src) or {
            failed << '${c.name}: parse error: ${err}'
            continue
        }
        got := doc.to_json()
        matched := json_logically_eq(got, c.expected) or {
            failed << '${c.name}: invalid JSON produced: ${got} (vs expected ${c.expected}): ${err}'
            continue
        }
        if !matched {
            failed << '${c.name}: got ${got}, want ${c.expected}'
        }
    }
    if failed.len > 0 {
        eprintln('YAML conformance failures (${failed.len}/${cases.len}):')
        for f in failed {
            eprintln('  - ${f}')
        }
        assert false, '${failed.len} conformance case(s) failed'
    }
}