// Third-party conformance: drives the entire `appendix_a.json` corpus
// from https://github.com/cbor/test-vectors (the same file that ciborium,
// serde_cbor and cbor2 use). Each entry is checked against:
//
//   * its `hex` round-trips byte-exact when `roundtrip == true`
//   * its `decoded` JSON value matches the V-decoded `cbor.Value`
//   * for entries that only carry a `diagnostic` (NaN, Infinity, undefined,
//     simple(N), tag(N)(...), h'…'), structural sanity is enforced via
//     the diagnostic prefix.
//
// The fixture file lives next to this test so the corpus is reproducible
// and offline-buildable.
module main

import encoding.cbor
import encoding.hex
import math
import os
import x.json2

fn h(s string) []u8 {
	return hex.decode(s) or { panic('bad hex ${s}') }
}

fn bytes_eq(a []u8, b []u8) bool {
	if a.len != b.len {
		return false
	}
	for i in 0 .. a.len {
		if a[i] != b[i] {
			return false
		}
	}
	return true
}

// match_decoded compares a V `Value` against a parsed JSON value from the
// vector's `decoded` field. Returns an error string on mismatch; empty on success.
fn match_decoded(v cbor.Value, j json2.Any) string {
	match j {
		i64 {
			match v {
				cbor.IntNum {
					if j >= 0 {
						if v.negative || v.magnitude != u64(j) {
							return 'int ${j} ↔ IntNum(neg=${v.negative}, mag=${v.magnitude})'
						}
					} else {
						mag := u64(-(j + 1))
						if !v.negative || v.magnitude != mag {
							return 'int ${j} ↔ IntNum(neg=${v.negative}, mag=${v.magnitude})'
						}
					}
					return ''
				}
				cbor.Tag {
					// JSON ints beyond ±2^63 land here as i64-clamped or as a string;
					// real bignum vectors use the `decoded` field with a u64 / negative,
					// so this branch shouldn't fire for that case.
					return 'unexpected Tag for plain int ${j}'
				}
				else {
					return 'expected int ${j}, got ${v.type_name()}'
				}
			}
		}
		u64 {
			if v is cbor.IntNum {
				if v.negative || v.magnitude != j {
					return 'uint ${j} ↔ IntNum(neg=${v.negative}, mag=${v.magnitude})'
				}
				return ''
			}
			return 'expected uint ${j}'
		}
		f64 {
			// JSON has a single number type, so an integer-valued vector
			// arrives here as f64 even when the CBOR is major type 0/1.
			if v is cbor.FloatNum {
				if math.is_nan(j) && math.is_nan(v.value) {
					return ''
				}
				if v.value != j {
					return 'float ${j} ↔ ${v.value}'
				}
				return ''
			}
			if v is cbor.IntNum {
				// Beyond 2^53 JSON's f64 representation loses precision —
				// we can't tell IntNum(2^64-1) from IntNum(2^64). Trust the
				// roundtrip byte check and accept the structural shape.
				f64_exact_int_max := f64(1) * f64(u64(1) << 53)
				if math.abs(j) >= f64_exact_int_max {
					return ''
				}
				expected_neg := j < 0
				abs_val := if expected_neg { -j } else { j }
				if abs_val != f64(u64(abs_val)) {
					return 'float ${j} → IntNum: not integer-valued'
				}
				if expected_neg {
					if !v.negative {
						return 'expected negative IntNum for ${j}'
					}
					if u64(abs_val) - 1 != v.magnitude {
						return 'IntNum mag ${v.magnitude} != ${u64(abs_val) - 1}'
					}
				} else {
					if v.negative {
						return 'expected non-negative IntNum for ${j}'
					}
					if u64(abs_val) != v.magnitude {
						return 'IntNum mag ${v.magnitude} != ${u64(abs_val)}'
					}
				}
				return ''
			}
			if v is cbor.Tag {
				// Bignum (tag 2/3) representing a value beyond i64. Caller skips.
				return 'tag-bignum (caller decides)'
			}
			return 'expected number ${j}'
		}
		bool {
			if v is cbor.Bool && v.value == j {
				return ''
			}
			return 'expected bool ${j}'
		}
		string {
			if v is cbor.Text && v.value == j {
				return ''
			}
			return 'expected text "${j}"'
		}
		json2.Null {
			if v is cbor.Null {
				return ''
			}
			return 'expected null'
		}
		[]json2.Any {
			if v is cbor.Array {
				if v.elements.len != j.len {
					return 'array length ${v.elements.len} != ${j.len}'
				}
				for i, item in j {
					sub := match_decoded(v.elements[i], item)
					if sub != '' {
						return 'array[${i}]: ${sub}'
					}
				}
				return ''
			}
			return 'expected array'
		}
		map[string]json2.Any {
			if v is cbor.Map {
				if v.pairs.len != j.len {
					return 'map size ${v.pairs.len} != ${j.len}'
				}
				for pair in v.pairs {
					if pair.key !is cbor.Text {
						// JSON can only express string keys; mixed-key maps live
						// in the diagnostic-only set, so this is safe.
						return 'non-text key in JSON-comparable map'
					}
					tk := pair.key as cbor.Text
					if tk.value !in j {
						return 'missing key ${tk.value}'
					}
					jv := j[tk.value] or { return 'missing key ${tk.value}' }
					sub := match_decoded(pair.value, jv)
					if sub != '' {
						return 'map[${tk.value}]: ${sub}'
					}
				}
				return ''
			}
			return 'expected map'
		}
		else {
			return 'unsupported JSON kind ${typeof(j).name}'
		}
	}
}

// match_diagnostic enforces only structural sanity for entries that JSON
// can't directly express (NaN, Infinity, undefined, simple, tag, bignum).
fn match_diagnostic(v cbor.Value, diag string) string {
	d := diag.trim_space()
	match d {
		'Infinity' {
			if v is cbor.FloatNum && math.is_inf(v.value, 1) {
				return ''
			}
			return 'expected +Inf'
		}
		'-Infinity' {
			if v is cbor.FloatNum && math.is_inf(v.value, -1) {
				return ''
			}
			return 'expected -Inf'
		}
		'NaN' {
			if v is cbor.FloatNum && math.is_nan(v.value) {
				return ''
			}
			return 'expected NaN'
		}
		'undefined' {
			if v is cbor.Undefined {
				return ''
			}
			return 'expected Undefined'
		}
		else {}
	}

	if d.starts_with('simple(') {
		if v is cbor.Simple {
			return ''
		}
		return 'expected Simple'
	}
	if d.starts_with("h'") {
		if v is cbor.Bytes {
			return ''
		}
		return 'expected Bytes'
	}
	if d.starts_with('(_') {
		// Indefinite-length compound. Decoder collapses to definite Value.
		if v is cbor.Bytes || v is cbor.Text || v is cbor.Array || v is cbor.Map {
			return ''
		}
		return 'expected indef-collapsed compound'
	}
	// Tag forms: "0(\"...\")", "1(1363896240)", "23(h'…')", "24(h'…')", "32(\"…\")".
	if d.contains('(') && d[0].is_digit() {
		if v is cbor.Tag {
			return ''
		}
		return 'expected Tag'
	}
	// Map literal "{1: 2, 3: 4}" — int-keyed map, can't be expressed in JSON.
	if d.starts_with('{') {
		if v is cbor.Map {
			return ''
		}
		return 'expected Map'
	}
	return 'unrecognised diagnostic ${d}'
}

const fixture_path = os.join_path(os.dir(@FILE), 'appendix_a.json')

fn test_upstream_appendix_a_corpus() {
	raw := os.read_file(fixture_path) or { panic('cannot read fixture: ${err}') }
	parsed := json2.decode[json2.Any](raw) or { panic('json: ${err}') }
	entries := parsed.as_array()
	assert entries.len > 0, 'fixture is empty'

	mut total := 0
	mut roundtrip := 0
	mut value_checks := 0
	mut diag_checks := 0
	mut failures := []string{}

	for entry in entries {
		obj := entry.as_map()
		total++
		hex_str := obj['hex'] or { json2.Any('') }.str()
		// `f818` (simple(24) two-byte form) is well-formed under RFC 7049
		// but RFC 8949 §3.3 explicitly forbids it. The upstream corpus
		// predates RFC 8949 — our decoder correctly rejects it.
		if hex_str == 'f818' {
			cbor.decode[cbor.Value](h(hex_str), cbor.DecodeOpts{}) or {
				assert err.msg().contains('1-byte form'), 'unexpected error for f818: ${err}'
				continue
			}
			assert false, 'f818 should be rejected per RFC 8949 §3.3'
		}
		input := h(hex_str)
		rt := if rt_any := obj['roundtrip'] {
			rt_any.bool()
		} else {
			false
		}

		decoded_v := cbor.decode[cbor.Value](input, cbor.DecodeOpts{}) or {
			failures << 'decode ${hex_str}: ${err}'
			continue
		}

		// Compare structure where possible.
		if decoded := obj['decoded'] {
			diff := match_decoded(decoded_v, decoded)
			if diff != '' {
				// Bignums (decoded JSON ints beyond ±2^64) are represented as
				// `Tag(2|3, Bytes)` on the wire. JSON loses them as i64-clamped
				// values, so accept Tag/IntNum mismatch when the JSON is at the
				// extreme range.
				if decoded_v is cbor.Tag {
					t := decoded_v as cbor.Tag
					if t.number == 2 || t.number == 3 {
						value_checks++
						continue
					}
				}
				failures << '${hex_str} decoded: ${diff}'
				continue
			}
			value_checks++
		} else if diag := obj['diagnostic'] {
			diff := match_diagnostic(decoded_v, diag.str())
			if diff != '' {
				failures << '${hex_str} diagnostic "${diag}": ${diff}'
				continue
			}
			diag_checks++
		}

		// For roundtrip=true entries, re-encode and compare bytes.
		if rt {
			out := cbor.encode_value(decoded_v, cbor.EncodeOpts{})!
			if !bytes_eq(out, input) {
				failures << '${hex_str} roundtrip: got ${hex.encode(out)}'
				continue
			}
			roundtrip++
		}
	}

	if failures.len > 0 {
		for f in failures {
			eprintln('FAIL: ${f}')
		}
		assert false, '${failures.len}/${total} upstream Appendix A vectors failed'
	}

	// Sanity: the upstream corpus has 80+ entries; if we ever see less,
	// the fixture file is wrong.
	assert total >= 80, 'corpus too small: ${total}'
	assert roundtrip >= 60, 'too few roundtrip checks: ${roundtrip}'
	assert value_checks > 0
	assert diag_checks > 0
}