// CBOR Working Group conformance corpus
// (https://github.com/cbor-wg/cbor-test-vectors).
//
// Two fixture files live next to this test:
//
//   * `cbor_wg/rfc8949_good.edn` — 88 well-formed payloads. Each must
//     decode without error.
//   * `cbor_wg/rfc8949_bad.edn`  — 47 malformed payloads. Each MUST be
//     rejected by the decoder per RFC 8949 §3.
//
// The fixtures are EDN (CBOR Diagnostic Notation, RFC 8610) — we only
// pull the `"encoded": h'…'` hex literals because that's what we need
// to drive the decoder. The expected `decoded` value is left to the
// other test files (rfc8949_appendix_a, upstream_appendix_a) which use
// the JSON-encoded corpus.
module main

import encoding.cbor
import encoding.hex
import os

const wg_dir = os.join_path(os.dir(@FILE), 'cbor_wg')

// extract_hex_literals pulls every `"encoded": h'…'` value out of an EDN
// file. The hex string can contain whitespace (visual grouping per
// RFC 8610) — we strip it before decoding.
fn extract_hex_literals(text string) []string {
    mut out := []string{}
    mut i := 0
    needle := '"encoded": h\''
    for {
        idx := text.index_after(needle, i) or { break }
        start := idx + needle.len
        end := text.index_after("'", start) or { break }
        raw := text[start..end]
        mut clean := []u8{cap: raw.len}
        for c in raw {
            if c == ` ` || c == `\t` || c == `\n` || c == `\r` {
                continue
            }
            clean << c
        }
        out << clean.bytestr()
        i = end + 1
    }
    return out
}

fn test_extractor_sanity() {
    good := os.read_file(os.join_path(wg_dir, 'rfc8949_good.edn')) or {
        panic('cannot read good.edn: ${err}')
    }
    bad := os.read_file(os.join_path(wg_dir, 'rfc8949_bad.edn')) or {
        panic('cannot read bad.edn: ${err}')
    }
    good_hexes := extract_hex_literals(good)
    bad_hexes := extract_hex_literals(bad)
    assert good_hexes.len == 88, 'good corpus drift: ${good_hexes.len} (expected 88)'
    assert bad_hexes.len == 47, 'bad corpus drift: ${bad_hexes.len} (expected 47)'
}

fn test_cbor_wg_good_corpus() {
    text := os.read_file(os.join_path(wg_dir, 'rfc8949_good.edn'))!
    hexes := extract_hex_literals(text)
    // The corpus deliberately stresses 256+ deep nesting; raise the cap.
    opts := cbor.DecodeOpts{
        max_depth: 4096
    }
    mut failures := []string{}
    for hex_str in hexes {
        bytes := hex.decode(hex_str) or {
            failures << '${hex_str}: hex decode: ${err}'
            continue
        }
        cbor.decode[cbor.Value](bytes, opts) or {
            failures << '${hex_str}: ${err}'
            continue
        }
    }
    if failures.len > 0 {
        for f in failures {
            eprintln('GOOD-FAIL: ${f}')
        }
        assert false, '${failures.len}/${hexes.len} good vectors rejected'
    }
}

// Per-major-type files (mt0..mt7) and the streaming/indefinite suite all
// hold well-formed entries. Each must decode without error.
const mt_files = [
    'appA_mt0.edn',
    'appA_mt1.edn',
    'appA_mt2.edn',
    'appA_mt3.edn',
    'appA_mt4.edn',
    'appA_mt5.edn',
    'appA_mt6.edn',
    'appA_mt7-float.edn',
    'appA_mt7-simple.edn',
    'appA_streaming.edn',
]

fn test_cbor_wg_per_major_type_corpus() {
    mut total := 0
    mut failures := []string{}
    for fname in mt_files {
        text := os.read_file(os.join_path(wg_dir, fname)) or {
            panic('cannot read ${fname}: ${err}')
        }
        hexes := extract_hex_literals(text)
        assert hexes.len > 0, '${fname} has no entries'
        for hex_str in hexes {
            total++
            bytes := hex.decode(hex_str) or {
                failures << '${fname} ${hex_str}: hex: ${err}'
                continue
            }
            cbor.decode[cbor.Value](bytes, cbor.DecodeOpts{}) or {
                failures << '${fname} ${hex_str}: ${err}'
                continue
            }
        }
    }
    if failures.len > 0 {
        for f in failures {
            eprintln('MT-FAIL: ${f}')
        }
        assert false, '${failures.len}/${total} per-major-type vectors rejected'
    }
    assert total >= 80, 'corpus too small: ${total}'
}

fn test_cbor_wg_bad_corpus() {
    text := os.read_file(os.join_path(wg_dir, 'rfc8949_bad.edn'))!
    hexes := extract_hex_literals(text)
    mut accepted_anyway := []string{}
    for hex_str in hexes {
        bytes := hex.decode(hex_str) or {
            // Malformed at the hex layer is still a rejection; skip.
            continue
        }
        if v := cbor.decode[cbor.Value](bytes, cbor.DecodeOpts{}) {
            accepted_anyway << '${hex_str} → ${v.type_name()}'
        }
    }
    if accepted_anyway.len > 0 {
        for a in accepted_anyway {
            eprintln('BAD-ACCEPTED: ${a}')
        }
        assert false, '${accepted_anyway.len}/${hexes.len} malformed vectors were not rejected'
    }
}