module yaml

import os
import x.json2

// Edge-case coverage for parse_text + scalar parsing + serialization.
// Complements yaml_test.v which covers the happy path. Each fn targets one
// specific gap that a previous regression in the module would have silently
// passed.

fn test_parse_strips_utf8_bom() ! {
	src := '\xef\xbb\xbfname: app\nport: 8080\n'
	doc := parse_text(src)!
	assert doc.value('name').string() == 'app'
	assert doc.value('port').int() == 8080
}

fn test_parse_normalizes_crlf_and_cr() ! {
	a := parse_text('a: 1\r\nb: 2\r\n')!
	assert a.value('a').int() == 1
	assert a.value('b').int() == 2
	b := parse_text('a: 1\rb: 2\r')!
	assert b.value('a').int() == 1
	assert b.value('b').int() == 2
}

fn test_parse_empty_and_whitespace_only_documents() ! {
	// Per YAML 1.2, a document with no content is the null node.
	for src in ['', '   ', '\n\n', '   \n  \n'] {
		doc := parse_text(src)!
		assert doc.root is Null
	}
}

struct EmptyDecodeTarget {
	name string
	port int
}

fn test_decode_empty_document_yields_default_struct() ! {
	// An empty config file should decode to a zero-initialized struct, not
	// raise an error — even though the YAML root is Null per spec.
	for src in ['', '   ', '\n\n'] {
		got := decode[EmptyDecodeTarget](src)!
		assert got.name == ''
		assert got.port == 0
	}
}

fn test_parse_null_variants() ! {
	doc := parse_text('
a: ~
b: null
c: Null
d: NULL
e:
')!
	for k in ['a', 'b', 'c', 'd', 'e'] {
		v := doc.value(k)
		assert v is Null, '${k} should be Null, got ${typeof(v).name}'
	}
}

fn test_parse_bool_yaml11_variants() ! {
	doc := parse_text('
t1: true
t2: True
t3: TRUE
t4: yes
t5: YES
t6: on
t7: On
f1: false
f2: False
f3: no
f4: NO
f5: off
f6: Off
')!
	for k in ['t1', 't2', 't3', 't4', 't5', 't6', 't7'] {
		assert doc.value(k).bool(), '${k} should be true'
	}
	for k in ['f1', 'f2', 'f3', 'f4', 'f5', 'f6'] {
		assert !doc.value(k).bool(), '${k} should be false'
	}
}

fn test_parse_numeric_underscores_and_signs() ! {
	doc := parse_text('
a: 1_000_000
b: -42
c: +17
d: 1.5e10
e: -1.0e-5
')!
	assert doc.value('a').i64() == 1_000_000
	assert doc.value('b').int() == -42
	assert doc.value('c').u64() == 17
	assert doc.value('d').f64() == 1.5e10
	assert doc.value('e').f64() == -1.0e-5
}

fn test_parse_quoted_string_escapes() ! {
	doc := parse_text('
a: "line1\\nline2"
b: "tab\\there"
c: "quote: \\""
d: "unicode: \\u00e9"
e: \'sing\'\'le\'
')!
	assert doc.value('a').string() == 'line1\nline2'
	assert doc.value('b').string() == 'tab\there'
	assert doc.value('c').string() == 'quote: "'
	assert doc.value('d').string() == 'unicode: é'
	assert doc.value('e').string() == "sing'le"
}

fn test_parse_comment_inside_quoted_string_is_preserved() ! {
	doc := parse_text('a: "value with # not a comment"\nb: real # comment trimmed\n')!
	assert doc.value('a').string() == 'value with # not a comment'
	assert doc.value('b').string() == 'real'
}

fn test_parse_nested_flow_style() ! {
	doc := parse_text('root: {a: [1, [2, 3], {b: c, d: [e, f]}], g: 4}\n')!
	assert doc.value('root.a[0]').int() == 1
	assert doc.value('root.a[1]').array().len == 2
	assert doc.value('root.a[2].b').string() == 'c'
	assert doc.value('root.a[2].d[1]').string() == 'f'
	assert doc.value('root.g').int() == 4
}

fn test_parse_block_scalar_literal_and_folded() ! {
	doc := parse_text('
literal: |
  line1
  line2

  line4
folded: >
  hello
  world


  next paragraph
')!
	assert doc.value('literal').string() == 'line1\nline2\n\nline4\n'
	assert doc.value('folded').string() == 'hello world\n\nnext paragraph\n'
}

fn test_parse_rejects_tabs_in_indentation() {
	if _ := parse_text('a:\n\tb: 1\n') {
		assert false, 'tabs in indentation should error'
	} else {
		msg := err.msg()
		assert msg.contains('tabs are not supported')
		// Error must point at the offending line so the caller can locate it.
		// The tab is on line 2 of the input.
		assert msg.contains('line 2'), 'error should report line number, got: ${msg}'
	}
}

fn test_parse_rejects_unexpected_indentation_in_mapping() {
	if _ := parse_text('a: 1\n  b: 2\n') {
		assert false, 'over-indented mapping entry should error'
	} else {
		assert err.msg().contains('unexpected indentation')
	}
}

fn test_parse_json_superset_path() ! {
	// JSON-shaped input takes the json2 fast path in parse_text.
	doc := parse_text('{"a": [1, 2, {"b": "c"}], "d": null}')!
	assert doc.value('a[0]').int() == 1
	assert doc.value('a[2].b').string() == 'c'
	assert doc.value('d') is Null
}

fn test_parse_empty_inline_collections() ! {
	doc := parse_text('a: []\nb: {}\nc: [[]]\nd: [{}]\n')!
	assert doc.value('a').array().len == 0
	assert doc.value('b').as_map().len == 0
	assert doc.value('c').array().len == 1
	assert doc.value('d').array().len == 1
}

fn test_parse_deeply_nested_structure() ! {
	mut src := 'root:\n'
	mut indent := '  '
	for i in 0 .. 30 {
		src += '${indent}level${i}:\n'
		indent += '  '
	}
	src += '${indent}leaf: 42\n'
	doc := parse_text(src)!
	mut node := doc.value('root')
	for i in 0 .. 30 {
		node = node.value('level${i}')
	}
	assert node.value('leaf').int() == 42
}

fn test_to_yaml_roundtrip_preserves_structure() ! {
	src := 'name: app
servers:
  - host: a
    port: 1
  - host: b
    port: 2
'
	doc := parse_text(src)!
	yaml_text := doc.to_yaml()
	doc2 := parse_text(yaml_text)!
	assert doc2.value('name').string() == 'app'
	assert doc2.value('servers[0].host').string() == 'a'
	assert doc2.value('servers[1].port').int() == 2
}

fn test_to_yaml_is_stable_across_many_calls() ! {
	// Anti-regression for a real crash that used to surface only after many
	// repeated `to_yaml` calls on the same Doc (sumtype recursion through the
	// json2.Any rebuild path under -prod -gc boehm). 1000 iterations are
	// enough to flush the original failure mode without bloating CI runtime.
	doc := parse_text('
name: my-app
version: 1.2.3
servers:
  - host: a
    port: 1
  - host: b
    port: 2
features:
  enable_cache: true
  enable_metrics: true
')!
	first := doc.to_yaml()
	for _ in 0 .. 1000 {
		assert doc.to_yaml() == first
	}
}

fn test_to_json_emits_valid_json_for_unicode() ! {
	doc := parse_text('a: "café"\nb: "中文"\n')!
	out := doc.to_json()
	// Re-parse the output instead of asserting on a substring: this catches
	// real corruption of the strings, while staying agnostic to whitespace
	// and key ordering choices in the emitter.
	parsed := json2.decode[json2.Any](out)!
	mapped := parsed as map[string]json2.Any
	a := mapped['a'] or { return error('missing key a in re-parsed output') }
	b := mapped['b'] or { return error('missing key b in re-parsed output') }
	assert a.str() == 'café'
	assert b.str() == '中文'
}

fn test_to_json_escapes_special_chars() ! {
	doc := parse_text('a: "tab\there"\nb: "quote: \\""\n')!
	out := doc.to_json()
	parsed := json2.decode[json2.Any](out)!
	mapped := parsed as map[string]json2.Any
	a := mapped['a'] or { return error('missing key a in re-parsed output') }
	b := mapped['b'] or { return error('missing key b in re-parsed output') }
	assert a.str() == 'tab\there'
	assert b.str() == 'quote: "'
}

fn test_to_yaml_quotes_keys_consistently() ! {
	doc := parse_text('plain: 1\n"a.b": 2\n')!
	out := doc.to_yaml()
	// Both keys go through yaml_quote_string -> json.encode, so both end up
	// quoted. This guards against a future change that would silently switch
	// to plain-style and break round-tripping for keys containing dots.
	assert out.contains('"plain":')
	assert out.contains('"a.b":')
}

fn test_value_returns_null_for_missing_path() ! {
	doc := parse_text('a: 1\nb:\n  c: 2\n')!
	assert doc.value('z') is Null
	assert doc.value('a.does.not.exist') is Null
	assert doc.value('b.c.d') is Null
}

fn test_value_opt_errors_on_missing() ! {
	doc := parse_text('a: 1\n')!
	if _ := doc.value_opt('z') {
		assert false, 'expected error for missing key'
	}
}

fn test_value_returns_null_on_array_out_of_bounds() ! {
	doc := parse_text('a: [1, 2, 3]\n')!
	assert doc.value('a[99]') is Null
}

fn test_parse_skips_yaml_directives() ! {
	// `%YAML`, `%TAG`, and any other `%`-prefixed directive line is consumed
	// without becoming part of the document.
	doc := parse_text('%YAML 1.2\n%TAG !e! tag:example.com,2000:app/\n---\nname: app\n')!
	assert doc.value('name').string() == 'app'
}

fn test_parse_anchor_and_alias_resolution() ! {
	// `&id` registers the value, `*id` returns the same value at use sites.
	doc := parse_text('a: &x hello\nb: *x\nlist:\n  - &y 42\n  - *y\n')!
	assert doc.value('a').string() == 'hello'
	assert doc.value('b').string() == 'hello'
	assert doc.value('list[0]').int() == 42
	assert doc.value('list[1]').int() == 42
}

fn test_parse_unknown_alias_returns_null() ! {
	doc := parse_text('a: *missing\n')!
	assert doc.value('a') is Null
}

fn test_parse_file_happy_path() ! {
	path := os.join_path(os.vtmp_dir(), 'yaml_pf_${os.getpid()}.yml')
	defer {
		os.rm(path) or {}
	}
	os.write_file(path, 'name: app\nport: 8080\n')!
	doc := parse_file(path)!
	assert doc.value('name').string() == 'app'
	assert doc.value('port').int() == 8080
}

fn test_parse_file_returns_error_on_missing_path() {
	missing := os.join_path(os.vtmp_dir(), 'yaml_does_not_exist_${os.getpid()}.yml')
	if _ := parse_file(missing) {
		assert false, 'parse_file on missing path should error'
	}
}

fn test_parse_flow_collection_spanning_multiple_lines() ! {
	// Flow `[ ]` and `{ }` may wrap across lines; the parser must accumulate
	// until brackets balance.
	doc := parse_text('arr: [\n  1,\n  2,\n  3\n]\n')!
	assert doc.value('arr').array().len == 3
	assert doc.value('arr[2]').int() == 3
	doc2 := parse_text('obj: {\n  a: 1,\n  b: 2\n}\n')!
	assert doc2.value('obj.a').int() == 1
	assert doc2.value('obj.b').int() == 2
}