// Copyright (c) 2019-2024 V language community. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module strconv

// atou_common_check perform basics check on unsigned string to parse.
// Test emptiness, + sign presence, absence of minus sign, presence of digit after
// signs and no underscore as first character.
// returns s first digit index or an error.
@[direct_array_access]
fn atou_common_check(s string) !int {
    if s == '' {
        return error('strconv.atou: parsing "": empty string')
    }

    mut start_idx := 0

    if s[0] == `-` {
        return error('strconv.atou: parsing "{s}" : negative value')
    }

    if s[0] == `+` {
        start_idx++
    }

    if s.len - start_idx < 1 {
        return error('strconv.atou: parsing "${s}": no number after sign')
    }

    if s[start_idx] == `_` || s[s.len - 1] == `_` {
        return error('strconv.atou: parsing "${s}": values cannot start or end with underscores')
    }
    return start_idx
}

// atou_common performs computation for all u8, u16 and u32 type, excluding i64.
// Parse values, and returns consistent error message over differents types.
// s is string to parse, max is respective types max value.
@[direct_array_access]
fn atou_common(s string, type_max u64) !u64 {
    mut start_idx := int(atou_common_check(s)!)
    mut x := u64(0)
    mut underscored := false
    for i in start_idx .. s.len {
        c := s[i] - `0`
        if c == 47 { // 47 = Ascii(`_`) -  ascii(`0`) = 95 - 48.
            if underscored == true { // Two consecutives underscore
                return error('strconv.atou: parsing "${s}": consecutives underscores are not allowed')
            }
            underscored = true
            continue // Skip underscore
        } else {
            if c > 9 {
                return error('strconv.atou: parsing "${s}": invalid radix 10 character')
            }
            underscored = false

            if x > type_max / 10 {
                return error('strconv.atou: parsing "${s}": integer overflow')
            }
            x *= 10
            if x > type_max - u64(c) {
                return error('strconv.atou: parsing "${s}": integer overflow')
            }
            x += u64(c)
        }
    }
    return x
}

// atou8 is equivalent to parse_uint(s, 10, 0), converted to type u8.
// It returns u8 in range [0..255] or an Error.
pub fn atou8(s string) !u8 {
    return u8(atou_common(s, max_u8)!)
}

// atou16 is equivalent to parse_uint(s, 10, 0), converted to type u16.
// It returns u16 in range [0..65535] or an Error.
pub fn atou16(s string) !u16 {
    return u16(atou_common(s, max_u16)!)
}

// atou is equivalent to parse_uint(s, 10, 0), converted to type u32.
pub fn atou(s string) !u32 {
    return u32(atou_common(s, max_u32)!)
}

// atou32 is identical to atou. Here to provide a symmetrical API with atoi/atoi32
// It returns u32 in range [0..4294967295] or an Error.
pub fn atou32(s string) !u32 {
    return u32(atou_common(s, max_u32)!)
}

// atou64 is equivalent to parse_uint(s, 10, 0), converted to type u64.
// It returns u64 in range [0..18446744073709551615] or an Error.
pub fn atou64(s string) !u64 {
    return u64(atou_common(s, max_u64)!)
}