// Canonical encoding (RFC 8949 §4.2.1, "core deterministic encoding"):
// map keys are sorted by length-first lexicographic order of their
// encoded forms. Used for hashable / signable payloads.
module main

import encoding.cbor
import encoding.hex

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

fn beq(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
}

fn test_canonical_sorts_text_keys() {
    // Build a map with reverse-alphabetic insertion order; canonical
    // output should still emit keys "a", "b", "c", "d", "e".
    v := cbor.Value(cbor.Map{
        pairs: [
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'e'
                })
                value: cbor.Value(cbor.Text{
                    value: 'E'
                })
            },
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'b'
                })
                value: cbor.Value(cbor.Text{
                    value: 'B'
                })
            },
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'd'
                })
                value: cbor.Value(cbor.Text{
                    value: 'D'
                })
            },
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'a'
                })
                value: cbor.Value(cbor.Text{
                    value: 'A'
                })
            },
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'c'
                })
                value: cbor.Value(cbor.Text{
                    value: 'C'
                })
            },
        ]
    })
    got := cbor.encode_value(v, cbor.EncodeOpts{ canonical: true })!
    want := h('a56161614161626142616361436164614461656145')
    assert beq(got, want), 'canonical: got ${hex.encode(got)}, want ${hex.encode(want)}'
}

fn test_canonical_length_first_then_lex() {
    // Length-first ordering: shorter keys first.
    // {"a": 1, "aa": 2}  →  short before long.
    v := cbor.Value(cbor.Map{
        pairs: [
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'aa'
                })
                value: cbor.Value(cbor.new_uint(2))
            },
            cbor.MapPair{
                key:   cbor.Value(cbor.Text{
                    value: 'a'
                })
                value: cbor.Value(cbor.new_uint(1))
            },
        ]
    })
    got := cbor.encode_value(v, cbor.EncodeOpts{ canonical: true })!
    // Encoded keys "a"=0x6161 (2 bytes), "aa"=0x626161 (3 bytes).
    // Length-first: "a" first, then "aa".
    // Result: a2 61 61 01 62 61 61 02
    want := h('a2616101626161 02'.replace(' ', ''))
    assert beq(got, want), 'length-first: got ${hex.encode(got)}'
}

fn test_self_describe_prefix() {
    bytes := cbor.encode[u64](u64(0), cbor.EncodeOpts{ self_describe: true })!
    // Magic prefix: d9 d9 f7 then 0x00.
    assert beq(bytes, [u8(0xd9), 0xd9, 0xf7, 0x00])
}

// ---------------------------------------------------------------------
// Struct-as-map canonical encoding: declaration order MUST NOT leak
// into the wire form when canonical mode is on. Otherwise hash- or
// signature-based payloads (COSE, CWT, DAG-CBOR) lose stability across
// V versions whenever a field is added or reordered in source.
// ---------------------------------------------------------------------

struct OutOfOrder {
    zeta  int
    alpha int
    mid   int
}

fn test_canonical_struct_sorts_keys_by_encoded_form() {
    v := OutOfOrder{
        zeta:  1
        alpha: 2
        mid:   3
    }
    got := cbor.encode[OutOfOrder](v, cbor.EncodeOpts{ canonical: true })!
    // Length-first lex on encoded keys: "mid" (4B) < "zeta" (5B) < "alpha" (6B).
    // a3 636d6964 03 647a657461 01 65616c706861 02
    want := h('a3636d69640364 7a65746101 65616c706861 02'.replace(' ', ''))
    assert beq(got, want), 'declaration order leaked: got ${hex.encode(got)}'
}

fn test_canonical_struct_preserves_declaration_order_when_off() {
    // Default (non-canonical) keeps source order — important for human
    // inspection and matches the documented permissive behaviour.
    v := OutOfOrder{
        zeta:  1
        alpha: 2
        mid:   3
    }
    got := cbor.encode[OutOfOrder](v, cbor.EncodeOpts{})!
    // a3 647a657461 01 65616c706861 02 636d6964 03
    want := h('a3647a65746101 65616c706861 02 636d6964 03'.replace(' ', ''))
    assert beq(got, want), 'non-canonical reorder: got ${hex.encode(got)}'
}