module net

import os

// Conformance tests for RFC 5952 (IPv6 text representation).
//
// Each vector is `(input_form, expected_canonical)`. Inputs include
// non-canonical legitimate forms (uppercase, leading zeros, partial
// "::" placement) so that canonical_ipv6() also exercises the parser.

struct V6Vec {
    input    string
    expected string
}

const rfc5952_vectors = [
    // -------- §4.1 Leading zeros MUST be suppressed --------
    V6Vec{'2001:0db8:0000:0000:0000:0000:0000:0001', '2001:db8::1'},
    V6Vec{'0000:0000:0000:0000:0000:0000:0000:0000', '::'},
    V6Vec{'0000:0000:0000:0000:0000:0000:0000:0001', '::1'},
    // "A single 16-bit 0000 field MUST be represented as 0."
    V6Vec{'2001:0db8:0000:0001:0001:0001:0001:0001', '2001:db8:0:1:1:1:1:1'},
    // -------- §4.2.1 Shorten as much as possible --------
    V6Vec{'2001:db8:0:0:0:0:2:1', '2001:db8::2:1'},
    // Counter-example from the RFC: "2001:db8::0:1 is not acceptable".
    V6Vec{'2001:db8:0:0:0:0:0:1', '2001:db8::1'},
    // -------- §4.2.2 "::" MUST NOT shorten just one 16-bit 0 field --------
    // "2001:db8::1:1:1:1:1 is not correct" — single 0, leave as 0.
    V6Vec{'2001:db8:0:1:1:1:1:1', '2001:db8:0:1:1:1:1:1'},
    // Several singletons, none shortened:
    V6Vec{'1:0:1:0:1:0:1:0', '1:0:1:0:1:0:1:0'},
    V6Vec{'0:1:0:1:0:1:0:1', '0:1:0:1:0:1:0:1'},
    // -------- §4.2.3 Longest run wins; ties → first run --------
    // Three zeros (0,0,0) at positions 1..3 outweighs two zeros at 4..5.
    V6Vec{'2001:0:0:0:1:0:0:1', '2001::1:0:0:1'},
    // Tie: two equal pairs (0,0) at positions 2..3 and 5..6 — first wins.
    V6Vec{'2001:db8:0:0:1:0:0:1', '2001:db8::1:0:0:1'},
    // Earlier example from §4.2.3 with three trailing zero fields:
    V6Vec{'2001:0:0:1:0:0:0:1', '2001:0:0:1::1'},
    // -------- §4.3 Lowercase --------
    V6Vec{'2001:0DB8:AC10:FE01:0000:0000:0000:0000', '2001:db8:ac10:fe01::'},
    V6Vec{'FE80::1', 'fe80::1'},
    V6Vec{'FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF', 'ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'},
    // -------- §5 IPv4-mapped (::ffff:0:0/96) → mixed notation --------
    V6Vec{'0:0:0:0:0:ffff:c000:0201', '::ffff:192.0.2.1'},
    V6Vec{'::ffff:192.0.2.1', '::ffff:192.0.2.1'},
    V6Vec{'0000:0000:0000:0000:0000:FFFF:0A00:0001', '::ffff:10.0.0.1'},
    V6Vec{'::ffff:0.0.0.0', '::ffff:0.0.0.0'},
    V6Vec{'::ffff:255.255.255.255', '::ffff:255.255.255.255'},
    // -------- Run at start (>=2) --------
    V6Vec{'0:0:0:0:0:0:0:2', '::2'},
    V6Vec{'0:0:0:0:0:0:1:2', '::1:2'},
    V6Vec{'0:0:c:d:e:f:1:2', '::c:d:e:f:1:2'},
    // -------- Run at end (>=2) --------
    V6Vec{'1::', '1::'},
    V6Vec{'1:0:0:0:0:0:0:0', '1::'},
    V6Vec{'a:b:c:d:e:f:0:0', 'a:b:c:d:e:f::'},
    V6Vec{'2001:db8:ac10:fe01::', '2001:db8:ac10:fe01::'},
    // -------- Run in the middle --------
    V6Vec{'2001:db8::1', '2001:db8::1'},
    V6Vec{'fe80:0:0:0:0:0:0:1', 'fe80::1'},
    // -------- Loopback / unspecified --------
    V6Vec{'::1', '::1'},
    V6Vec{'::', '::'},
    // -------- No zero field at all --------
    V6Vec{'1:2:3:4:5:6:7:8', '1:2:3:4:5:6:7:8'},
    V6Vec{'2001:db8:1:2:3:4:5:6', '2001:db8:1:2:3:4:5:6'},
    // -------- Mixed leading-zero suppression with longer/shorter values --------
    V6Vec{'0001:0023:0456:7890:abcd:00ef:0:1', '1:23:456:7890:abcd:ef:0:1'},
    // -------- Two equal-length non-trivial runs (§4.2.3 tie) --------
    V6Vec{'0:0:1:2:3:4:0:0', '::1:2:3:4:0:0'},
    // -------- Run of length exactly 2 still triggers compression --------
    V6Vec{'1:2:0:0:3:4:5:6', '1:2::3:4:5:6'},
    // -------- Adjacent zero singletons: NEITHER must be compressed when
    //          a longer run exists --------
    V6Vec{'0:1:0:0:0:1:0:1', '0:1::1:0:1'},
    // -------- Parser robustness --------
    V6Vec{'2001:DB8::AB:CD', '2001:db8::ab:cd'},
    V6Vec{'::ffff:192.000.002.001', '::ffff:192.0.2.1'},
]!

fn test_rfc5952_vectors() {
    mut failures := []string{}
    for v in rfc5952_vectors {
        got := canonical_ipv6(v.input) or {
            failures << '${v.input} -> error: ${err}'
            continue
        }
        if got != v.expected {
            failures << '${v.input} -> got ${got}, want ${v.expected}'
        }
    }
    if failures.len > 0 {
        for f in failures {
            eprintln('  FAIL: ${f}')
        }
        assert false, '${failures.len}/${rfc5952_vectors.len} RFC 5952 vectors failed'
    }
}

fn test_from_bytes_basic() {
    zeros := []u8{len: 16}
    assert canonical_ipv6_from_bytes(zeros)! == '::'

    mut loop := []u8{len: 16}
    loop[15] = 1
    assert canonical_ipv6_from_bytes(loop)! == '::1'

    bytes := [u8(0x20), 0x01, 0x0d, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]
    assert canonical_ipv6_from_bytes(bytes)! == '2001:db8::1'

    mapped := [u8(0), 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 192, 0, 2, 1]
    assert canonical_ipv6_from_bytes(mapped)! == '::ffff:192.0.2.1'
}

fn test_from_bytes_rejects_wrong_length() {
    if _ := canonical_ipv6_from_bytes([u8(0)]) {
        assert false, 'must reject 1-byte input'
    }
    if _ := canonical_ipv6_from_bytes([]u8{len: 15}) {
        assert false, 'must reject 15-byte input'
    }
    if _ := canonical_ipv6_from_bytes([]u8{len: 17}) {
        assert false, 'must reject 17-byte input'
    }
}

fn test_canonical_is_idempotent() {
    for v in rfc5952_vectors {
        once := canonical_ipv6(v.input) or {
            assert false, 'first pass failed on ${v.input}: ${err}'
            continue
        }
        twice := canonical_ipv6(once) or {
            assert false, 'second pass failed on ${once}: ${err}'
            continue
        }
        assert once == twice, 'idempotence broken: ${v.input} -> ${once} -> ${twice}'
    }
}

fn test_parser_rejects_malformed() {
    bad := [
        '',
        'gggg::1', // non-hex
        '1::2::3', // two "::"
        '1:2:3:4:5:6:7:8:9', // too many groups, no "::"
        '1:2:3:4:5:6:7', // too few groups, no "::"
        '1:2:3:4:5:6:7:8::', // "::" with already 8 groups
        '12345::1', // group too long
        '1:2:3:4:5:6:1.2.3', // bad dotted quad (3 octets)
        '1:2:3:4:5:6:1.2.3.4.5', // bad dotted quad (5 octets)
        '::ffff:1.2.3.999', // octet > 255
        '::ffff:1.2.3.', // trailing dot in v4
    ]
    for s in bad {
        if _ := canonical_ipv6(s) {
            assert false, 'parser must reject "${s}"'
        }
    }
}

// test_inet_ntop_corpus loads testdata/ipv6_rfc5952.tsv (113 vectors
// generated by Python's ipaddress.IPv6Address.compressed) and confirms
// our pure-V implementation produces byte-identical output.
fn test_inet_ntop_corpus() {
    path := os.join_path(os.dir(@FILE), 'testdata', 'ipv6_rfc5952.tsv')
    body := os.read_file(path) or {
        assert false, 'cannot read fixture ${path}: ${err}'
        return
    }
    mut total := 0
    mut failed := []string{}
    for raw in body.split('\n') {
        line := raw.trim_space()
        if line.len == 0 {
            continue
        }
        fields := line.split('\t')
        if fields.len != 2 {
            assert false, 'bad fixture line: ${line}'
            continue
        }
        hex_addr := fields[0]
        want := fields[1]
        bytes := hex_to_bytes(hex_addr) or {
            assert false, 'bad hex: ${hex_addr}'
            continue
        }
        got := canonical_ipv6_from_bytes(bytes) or {
            failed << '${hex_addr}: ${err}'
            continue
        }
        if got != want {
            failed << '${hex_addr}: got "${got}", want "${want}"'
        }
        total++
    }
    if failed.len > 0 {
        for f in failed {
            eprintln('  FAIL: ${f}')
        }
        assert false, '${failed.len}/${total} cross-check vectors failed'
    }
    assert total >= 100, 'expected >= 100 vectors, got ${total}'
}

fn hex_to_bytes(s string) ![]u8 {
    if s.len % 2 != 0 {
        return error('hex_to_bytes: odd length')
    }
    mut out := []u8{cap: s.len / 2}
    for i := 0; i < s.len; i += 2 {
        hi := hex_digit(s[i]) or { return error('bad hex at ${i}') }
        lo := hex_digit(s[i + 1]) or { return error('bad hex at ${i + 1}') }
        out << (hi << 4) | lo
    }
    return out
}

// Property: bytes -> canonical -> parse -> bytes round-trip + idempotence.
fn test_property_roundtrip_and_idempotence() {
    mut state := u64(0xCAFEBABEDEADBEEF)
    for iter in 0 .. 1000 {
        mut bytes := []u8{cap: 16}
        for _ in 0 .. 16 {
            state = state * 6364136223846793005 + 1442695040888963407
            bytes << u8(state >> 56)
        }
        if iter % 5 == 0 {
            run_start := int((state >> 8) & 0x7)
            run_len := int((state >> 16) & 0x7) + 1
            for k in 0 .. run_len {
                idx := 2 * (run_start + k)
                if idx + 1 < bytes.len {
                    bytes[idx] = 0
                    bytes[idx + 1] = 0
                }
            }
        }
        canon := canonical_ipv6_from_bytes(bytes) or {
            assert false, 'canonical_ipv6_from_bytes failed on iter ${iter}: ${err}'
            continue
        }
        parsed := parse_ipv6_to_bytes(canon) or {
            assert false, 'parse_ipv6_to_bytes failed on canonical "${canon}" (iter ${iter}): ${err}'
            continue
        }
        assert parsed == bytes, 'round-trip mismatch on iter ${iter}: bytes=${bytes.hex()}, canon="${canon}", parsed=${parsed.hex()}'

        canon2 := canonical_ipv6(canon) or {
            assert false, 'canonical_ipv6 failed on its own output "${canon}" (iter ${iter}): ${err}'
            continue
        }
        assert canon == canon2, 'idempotence broken on iter ${iter}: "${canon}" -> "${canon2}"'
    }
}

fn test_alternative_forms_canonicalize_identically() {
    cases := [
        ['2001:db8:0:0:0:0:0:1', '2001:db8::1'],
        ['2001:DB8:0000:0000:0000:0000:0000:0001', '2001:db8::1'],
        ['2001:0db8::0001', '2001:db8::1'],
        ['2001:DB8::1', '2001:db8::1'],
        ['0:0:0:0:0:0:0:0', '::'],
        ['0000:0000:0000:0000:0000:0000:0000:0000', '::'],
        ['0:0:0:0:0:ffff:c0a8:0001', '::ffff:192.168.0.1'],
        ['::FFFF:192.168.0.1', '::ffff:192.168.0.1'],
        ['::ffff:c0a8:1', '::ffff:192.168.0.1'],
        ['fe80:0:0:0:0:0:0:1', 'fe80::1'],
        ['FE80::0:0:0:1', 'fe80::1'],
    ]
    for c in cases {
        got := canonical_ipv6(c[0]) or {
            assert false, 'canonical_ipv6("${c[0]}") errored: ${err}'
            continue
        }
        assert got == c[1], '"${c[0]}" -> got "${got}", want "${c[1]}"'
    }
}

fn test_well_known_corpus() {
    assert canonical_ipv6('::')! == '::'
    assert canonical_ipv6('::1')! == '::1'
    assert canonical_ipv6('1::')! == '1::'
    assert canonical_ipv6('fe80::1')! == 'fe80::1'
    assert canonical_ipv6('2001:db8::')! == '2001:db8::'
    assert canonical_ipv6('2001:db8:0:0:0:0:0:1')! == '2001:db8::1'
    assert canonical_ipv6('2001:db8:0:0:1:0:0:1')! == '2001:db8::1:0:0:1'
    // §5 is opt-in for non-::ffff:0:0/96 prefixes; we keep them as hex.
    assert canonical_ipv6('64:ff9b::192.0.2.33')! == '64:ff9b::c000:221'
}