// Generic encode[T]/decode[T] coverage. Exercises every supported V
// type family — primitives, arrays, maps, structs (with attributes),
// optional fields, enums, RawMessage, Marshaler/Unmarshaler — and
// asserts byte-exact output for at least one case per family so we
// catch silent encoding drift.
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
}

// ---------------------------------------------------------------------
// Primitive round-trips
// ---------------------------------------------------------------------

fn test_round_trip_primitives() {
    bytes_bool := cbor.encode[bool](true, cbor.EncodeOpts{})!
    assert cbor.decode[bool](bytes_bool, cbor.DecodeOpts{})! == true

    bytes_i32 := cbor.encode[i32](-42, cbor.EncodeOpts{})!
    assert cbor.decode[i32](bytes_i32, cbor.DecodeOpts{})! == -42

    bytes_u64 := cbor.encode[u64](u64(0x1234_5678_9abc_def0), cbor.EncodeOpts{})!
    assert cbor.decode[u64](bytes_u64, cbor.DecodeOpts{})! == 0x1234_5678_9abc_def0

    bytes_f64 := cbor.encode[f64](3.141592653589793, cbor.EncodeOpts{})!
    assert cbor.decode[f64](bytes_f64, cbor.DecodeOpts{})! == 3.141592653589793

    bytes_str := cbor.encode[string]('hello, 世界', cbor.EncodeOpts{})!
    assert cbor.decode[string](bytes_str, cbor.DecodeOpts{})! == 'hello, 世界'
}

// ---------------------------------------------------------------------
// Arrays and maps
// ---------------------------------------------------------------------

fn test_array_round_trip() {
    src := [1, 2, 3, 4, 5]
    bytes := cbor.encode[[]int](src, cbor.EncodeOpts{})!
    got := cbor.decode[[]int](bytes, cbor.DecodeOpts{})!
    assert got == src
}

fn test_map_round_trip() {
    src := {
        'a': 1
        'b': 2
        'c': 3
    }
    bytes := cbor.encode[map[string]int](src, cbor.EncodeOpts{})!
    got := cbor.decode[map[string]int](bytes, cbor.DecodeOpts{})!
    for k, v in src {
        assert got[k] == v
    }
    assert got.len == src.len
}

fn test_nested_array_map() {
    src := [
        {
            'k': 'v1'
        },
        {
            'k': 'v2'
        },
    ]
    bytes := cbor.encode[[]map[string]string](src, cbor.EncodeOpts{})!
    got := cbor.decode[[]map[string]string](bytes, cbor.DecodeOpts{})!
    assert got.len == 2
    assert got[0]['k'] == 'v1'
    assert got[1]['k'] == 'v2'
}

// ---------------------------------------------------------------------
// Structs — attributes, optional, rename strategies
// ---------------------------------------------------------------------

struct Person {
    name string
    age  int
}

fn test_struct_basic() {
    p := Person{
        name: 'Alice'
        age:  42
    }
    bytes := cbor.encode[Person](p, cbor.EncodeOpts{})!
    got := cbor.decode[Person](bytes, cbor.DecodeOpts{})!
    assert got.name == 'Alice'
    assert got.age == 42
}

struct WithAttrs {
    user_id  string @[cbor: 'uid']
    password string @[skip]
    internal string @[cbor: '-']
    keep     string
}

fn test_struct_attributes() {
    p := WithAttrs{
        user_id:  'u-1'
        password: 'secret'
        internal: 'hidden'
        keep:     'visible'
    }
    bytes := cbor.encode[WithAttrs](p, cbor.EncodeOpts{})!
    // Decode generically to inspect structure.
    v := cbor.decode[cbor.Value](bytes, cbor.DecodeOpts{})!
    assert v is cbor.Map
    if v is cbor.Map {
        mut keys := []string{}
        for pair in v.pairs {
            if pair.key is cbor.Text {
                keys << pair.key.value
            }
        }
        assert 'uid' in keys
        assert 'keep' in keys
        assert 'password' !in keys
        assert 'internal' !in keys
    }
    got := cbor.decode[WithAttrs](bytes, cbor.DecodeOpts{})!
    assert got.user_id == 'u-1'
    assert got.keep == 'visible'
}

struct WithOption {
    name string
    tag  ?string
}

fn test_struct_option_field() {
    none_p := WithOption{
        name: 'a'
        tag:  none
    }
    bytes := cbor.encode[WithOption](none_p, cbor.EncodeOpts{})!
    got := cbor.decode[WithOption](bytes, cbor.DecodeOpts{})!
    assert got.name == 'a'
    assert got.tag == none

    some_p := WithOption{
        name: 'b'
        tag:  ?string('hot')
    }
    bytes2 := cbor.encode[WithOption](some_p, cbor.EncodeOpts{})!
    got2 := cbor.decode[WithOption](bytes2, cbor.DecodeOpts{})!
    assert got2.name == 'b'
    assert got2.tag != none
    assert got2.tag or { '' } == 'hot'
}

@[cbor_rename_all: 'kebab-case']
struct WithRename {
    user_name string
    user_age  int
}

fn test_struct_rename_all() {
    p := WithRename{
        user_name: 'Bob'
        user_age:  30
    }
    bytes := cbor.encode[WithRename](p, cbor.EncodeOpts{})!
    v := cbor.decode[cbor.Value](bytes, cbor.DecodeOpts{})!
    if v is cbor.Map {
        mut keys := []string{}
        for pair in v.pairs {
            if pair.key is cbor.Text {
                keys << pair.key.value
            }
        }
        assert 'user-name' in keys
        assert 'user-age' in keys
    }
    // And the rename round-trips.
    got := cbor.decode[WithRename](bytes, cbor.DecodeOpts{})!
    assert got.user_name == 'Bob'
    assert got.user_age == 30
}

// ---------------------------------------------------------------------
// Enum
// ---------------------------------------------------------------------

enum Color {
    red
    green
    blue
}

fn test_enum_round_trip() {
    bytes := cbor.encode[Color](Color.green, cbor.EncodeOpts{})!
    got := cbor.decode[Color](bytes, cbor.DecodeOpts{})!
    assert got == Color.green
}

// ---------------------------------------------------------------------
// RawMessage — preserves bytes byte-for-byte
// ---------------------------------------------------------------------

fn test_raw_message_round_trip() {
    original := h('a26161016162820203')
    raw := cbor.decode[cbor.RawMessage](original, cbor.DecodeOpts{})!
    again := cbor.encode[cbor.RawMessage](raw, cbor.EncodeOpts{})!
    assert beq(again, original)
}

// ---------------------------------------------------------------------
// Marshaler / Unmarshaler — user-controlled wire format
// ---------------------------------------------------------------------

struct Ipv4 {
mut:
    octets [4]u8
}

pub fn (ip Ipv4) to_cbor() []u8 {
    mut p := cbor.new_packer(cbor.EncodeOpts{ initial_cap: 8 })
    p.pack_bytes([ip.octets[0], ip.octets[1], ip.octets[2], ip.octets[3]])
    return p.bytes().clone()
}

pub fn (mut ip Ipv4) from_cbor(data []u8) ! {
    mut u := cbor.new_unpacker(data, cbor.DecodeOpts{})
    bytes := u.unpack_bytes()!
    if bytes.len != 4 {
        return error('Ipv4: expected 4 bytes, got ${bytes.len}')
    }
    ip.octets[0] = bytes[0]
    ip.octets[1] = bytes[1]
    ip.octets[2] = bytes[2]
    ip.octets[3] = bytes[3]
}

fn test_marshaler_round_trip() {
    ip := Ipv4{
        octets: [u8(192), 168, 1, 1]!
    }
    bytes := cbor.encode[Ipv4](ip, cbor.EncodeOpts{})!
    // Wire bytes: 0x44 (bytes len 4) followed by 4 octets.
    assert beq(bytes, h('44c0a80101'))
    got := cbor.decode[Ipv4](bytes, cbor.DecodeOpts{})!
    assert got.octets[0] == 192
    assert got.octets[1] == 168
    assert got.octets[2] == 1
    assert got.octets[3] == 1
}

// ---------------------------------------------------------------------
// Integer-range checks on decode
// ---------------------------------------------------------------------

fn test_int_range_overflow_rejected() {
    // 256 doesn't fit u8.
    bytes := cbor.encode[u16](u16(256), cbor.EncodeOpts{})!
    if _ := cbor.decode[u8](bytes, cbor.DecodeOpts{}) {
        assert false, 'expected u8 range error'
    }
}

fn test_negative_to_unsigned_rejected() {
    bytes := cbor.encode[i64](-1, cbor.EncodeOpts{})!
    if _ := cbor.decode[u64](bytes, cbor.DecodeOpts{}) {
        assert false, 'expected u64 range error'
    }
}