module net

// IPv6 text representation per RFC 5952 (August 2010).
//
// Pure-V replacement for libc's inet_ntop on the IPv6 path. inet_ntop
// historically follows the older RFC 1884 / RFC 2373 rules and emits
// the deprecated IPv4-compatible mixed form (`::a.b.c.d`) for any
// address whose upper 96 bits are zero — non-conformant per RFC 5952
// §5, which restricts the mixed form to recognized IPv4-in-IPv6
// formats.
//
// Reference: https://www.rfc-editor.org/rfc/rfc5952
//
// Conformance summary:
//   §4.1   Leading zeros MUST be suppressed.                 ✓
//   §4.2.1 "::" MUST be used to its maximum capability.      ✓
//   §4.2.2 "::" MUST NOT shorten just one 16-bit 0 field.    ✓
//   §4.2.3 Longest run of zeros wins; ties: first run wins.  ✓
//   §4.3   Hex digits a-f MUST be lowercase.                 ✓
//   §5     IPv4-mapped (::ffff:0:0/96) uses dotted-quad      ✓
//          tail; the leading zeros and 0xffff are still
//          formatted per §4. Other IPv4-in-IPv6 formats
//          (ISATAP, IPv4-translatable) are not detectable
//          from the address bits alone and stay in hex.

// canonical_ipv6_from_bytes formats a 16-byte IPv6 address as the
// canonical text representation defined by RFC 5952. Errors only when
// the input slice is not exactly 16 octets long.
pub fn canonical_ipv6_from_bytes(b []u8) !string {
    if b.len != 16 {
        return error('canonical_ipv6_from_bytes: need 16 bytes, got ${b.len}')
    }
    mut groups := [8]u16{}
    for i in 0 .. 8 {
        groups[i] = (u16(b[2 * i]) << 8) | u16(b[2 * i + 1])
    }
    return format_ipv6_groups(groups)
}

// canonical_ipv6 takes any RFC 4291 legitimate text form (full,
// "::"-compressed, or with an embedded IPv4 dotted-quad tail) and
// returns the RFC 5952 canonical form.
pub fn canonical_ipv6(addr string) !string {
    bytes := parse_ipv6_to_bytes(addr)!
    return canonical_ipv6_from_bytes(bytes)
}

// format_ipv6_groups turns 8 u16 groups into the canonical RFC 5952
// string. Only the IPv4-mapped prefix (::ffff:0:0/96, RFC 4291)
// triggers mixed notation here — other RFC 5952 §5 prefixes
// (IPv4-translatable RFC 6052, ISATAP) require out-of-band knowledge
// and are not assumed.
fn format_ipv6_groups(g [8]u16) string {
    if is_ipv4_mapped(g) {
        a := g[6] >> 8
        b := g[6] & 0xff
        c := g[7] >> 8
        d := g[7] & 0xff
        return '::ffff:${a}.${b}.${c}.${d}'
    }

    start, length := longest_zero_run(g)

    mut parts := []string{cap: 8}
    for v in g {
        parts << v.hex()
    }

    if length < 2 {
        return parts.join(':')
    }

    mut out := ''
    if start > 0 {
        out += parts[..start].join(':')
    }
    out += '::'
    end := start + length
    if end < 8 {
        out += parts[end..].join(':')
    }
    return out
}

// is_ipv4_mapped tests for the ::ffff:0:0/96 prefix (RFC 4291 §2.5.5.2).
fn is_ipv4_mapped(g [8]u16) bool {
    return g[0] == 0 && g[1] == 0 && g[2] == 0 && g[3] == 0 && g[4] == 0 && g[5] == 0xffff
}

// longest_zero_run scans the 8 groups for the longest contiguous run of
// 0x0000 fields and returns (start_index, length). On ties the FIRST
// run wins (RFC 5952 §4.2.3). When no zero is present, length is 0.
fn longest_zero_run(g [8]u16) (int, int) {
    mut best_start := 0
    mut best_len := 0
    mut cur_start := 0
    mut cur_len := 0
    for i in 0 .. 8 {
        if g[i] == 0 {
            if cur_len == 0 {
                cur_start = i
            }
            cur_len++
            if cur_len > best_len {
                best_len = cur_len
                best_start = cur_start
            }
        } else {
            cur_len = 0
        }
    }
    return best_start, best_len
}

// parse_ipv6_to_bytes accepts the legitimate RFC 4291 forms:
//   - 8 groups of 1..4 hex digits separated by ':'
//   - the same with one "::" run replacing one or more all-zero groups
//   - the same with the trailing 32 bits given as dotted-quad IPv4
// Returns 16 octets in network order.
fn parse_ipv6_to_bytes(s string) ![]u8 {
    if s == '' {
        return error('parse_ipv6: empty')
    }
    double_idx := s.index('::') or { -1 }
    if s.count('::') > 1 {
        return error('parse_ipv6: multiple "::" runs')
    }

    head, tail := if double_idx >= 0 {
        s[..double_idx], s[double_idx + 2..]
    } else {
        s, ''
    }

    mut head_g := if head == '' { []string{} } else { head.split(':') }
    mut tail_g := if tail == '' { []string{} } else { tail.split(':') }
    mut v4_bytes := []u8{}

    // Detect dotted-quad tail in the LAST group (of tail when "::" present,
    // of head otherwise).
    tail_owns_last := double_idx >= 0
    last_group := if tail_owns_last && tail_g.len > 0 {
        tail_g[tail_g.len - 1]
    } else if !tail_owns_last && head_g.len > 0 {
        head_g[head_g.len - 1]
    } else {
        ''
    }
    if last_group.contains('.') {
        v4_bytes = parse_dotted_quad(last_group)!
        if tail_owns_last {
            tail_g = tail_g[..tail_g.len - 1].clone()
        } else {
            head_g = head_g[..head_g.len - 1].clone()
        }
    }

    mut head_words := []u16{}
    for h in head_g {
        head_words << parse_hex_group(h)!
    }
    mut tail_words := []u16{}
    for t in tail_g {
        tail_words << parse_hex_group(t)!
    }

    v4_word_len := if v4_bytes.len == 4 { 2 } else { 0 }
    total := head_words.len + tail_words.len + v4_word_len
    if double_idx < 0 {
        if total != 8 {
            return error('parse_ipv6: ${s} must have exactly 8 groups (got ${total})')
        }
    } else {
        if total >= 8 {
            return error('parse_ipv6: "::" present but address already has ${total} groups')
        }
    }

    mut words := []u16{cap: 8}
    for w in head_words {
        words << w
    }
    if double_idx >= 0 {
        for _ in 0 .. (8 - total) {
            words << u16(0)
        }
    }
    for w in tail_words {
        words << w
    }
    if v4_bytes.len == 4 {
        words << (u16(v4_bytes[0]) << 8) | u16(v4_bytes[1])
        words << (u16(v4_bytes[2]) << 8) | u16(v4_bytes[3])
    }

    if words.len != 8 {
        return error('parse_ipv6: internal: expanded to ${words.len} groups')
    }

    mut out := []u8{cap: 16}
    for w in words {
        out << u8(w >> 8)
        out << u8(w & 0xff)
    }
    return out
}

fn parse_hex_group(s string) !u16 {
    if s == '' || s.len > 4 {
        return error('parse_ipv6: bad hex group "${s}"')
    }
    mut v := u32(0)
    for c in s {
        d := hex_digit(c) or { return error('parse_ipv6: non-hex char in "${s}"') }
        v = (v << 4) | u32(d)
    }
    return u16(v)
}

fn hex_digit(c u8) ?u8 {
    if c >= `0` && c <= `9` {
        return u8(c - `0`)
    }
    if c >= `a` && c <= `f` {
        return u8(c - `a` + 10)
    }
    if c >= `A` && c <= `F` {
        return u8(c - `A` + 10)
    }
    return none
}

fn parse_dotted_quad(s string) ![]u8 {
    parts := s.split('.')
    if parts.len != 4 {
        return error('parse_ipv6: bad dotted-quad "${s}"')
    }
    mut out := []u8{cap: 4}
    for p in parts {
        if p.len == 0 || p.len > 3 {
            return error('parse_ipv6: bad octet "${p}"')
        }
        mut v := u32(0)
        for c in p {
            if c < `0` || c > `9` {
                return error('parse_ipv6: non-digit in octet "${p}"')
            }
            v = v * 10 + u32(c - `0`)
        }
        if v > 255 {
            return error('parse_ipv6: octet "${p}" > 255')
        }
        out << u8(v)
    }
    return out
}