//! Formatting utilities for converting values to strings.

use super::mem;

/// Maximum `u64` value.

export constant U64_MAX: u64 = 0xFFFFFFFFFFFFFFFF;

/// Maximum string length for a formatted u32 (eg. "4294967295").

export constant U32_STR_LEN: u32 = 10;

/// Maximum string length for a formatted i32 (eg. "-2147483648").

export constant I32_STR_LEN: u32 = U32_STR_LEN + 1;

/// Maximum string length for a formatted u64 (eg. "18446744073709551615").

export constant U64_STR_LEN: u32 = 20;

/// Maximum string length for a formatted i64 (eg. "-9223372036854775808").

export constant I64_STR_LEN: u32 = 20;

/// Maximum string length for a formatted bool (eg. "false").

export constant BOOL_STR_LEN: u32 = 5;

/// Radix/base of a parsed integer literal.

export union Radix: Copy {

    /// Binary literal (0b...).

    Binary,

    /// Decimal literal.

    Decimal,

    /// Hexadecimal literal (0x...).

    Hex,

}

/// Errors reported while parsing literal text.

export union ParseError: Copy {

    /// Literal text was empty or missing required digits.

    Invalid,

    /// Literal contained an invalid digit for its radix.

    InvalidDigit,

    /// Literal value exceeded the supported range.

    Overflow,

}

/// Parsed integer literal metadata.

export record IntLiteral: Copy {

    /// Raw characters that comprised the literal.

    text: *[u8],

    /// Magnitude parsed from the literal.

    magnitude: u64,

    /// Radix used by the literal.

    radix: Radix,

}

/// Write a u32 at the end of the buffer and return its start offset.

export fn formatU32(val: u32, buffer: &mut [u8]) -> u32 {

    assert buffer.len >= U32_STR_LEN;

    let mut x: u32 = val;

    let mut i: u32 = buffer.len;

    // Handle the zero case separately to ensure a single '0' is written.

    if x == 0 {

        set i -= 1;

        set buffer[i] = '0';

    } else {

        // Write digits backwards from the end of the buffer.

        while x <> 0 {

            set i -= 1;

            set buffer[i] = ('0' + (x % 10) as u8);

            set x /= 10;

        }

    }

    // Return the offset of the first written byte.

    return i;

}

/// Write a i32 at the end of the buffer and return its start offset.

export fn formatI32(val: i32, buffer: &mut [u8]) -> u32 {

    assert buffer.len >= I32_STR_LEN;

    let neg: bool = val < 0;

    let mut x: u32 = -val as u32 if neg else val as u32;

    let mut i: u32 = buffer.len;

    // Handle the zero case separately to ensure a single '0' is written.

    if x == 0 {

        set i -= 1;

        set buffer[i] = '0';

    } else {

        // Write digits backwards from the end of the buffer.

        while x <> 0 {

            set i -= 1;

            set buffer[i] = '0' + (x % 10) as u8;

            set x /= 10;

        }

        // Add the negative sign if needed.

        if neg {

            set i -= 1;

            set buffer[i] = '-';

        }

    }

    return i;

}

/// Write a u64 at the end of the buffer and return its start offset.

export fn formatU64(val: u64, buffer: &mut [u8]) -> u32 {

    assert buffer.len >= U64_STR_LEN;

    let mut x: u64 = val;

    let mut i: u32 = buffer.len;

    if x == 0 {

        set i -= 1;

        set buffer[i] = '0';

    } else {

        while x <> 0 {

            set i -= 1;

            set buffer[i] = ('0' + (x % 10) as u8);

            set x /= 10;

        }

    }

    return i;

}

/// Write a i64 at the end of the buffer and return its start offset.

export fn formatI64(val: i64, buffer: &mut [u8]) -> u32 {

    assert buffer.len >= I64_STR_LEN;

    let neg: bool = val < 0;

    let mut x: u64 = -val as u64 if neg else val as u64;

    let mut i: u32 = buffer.len;

    if x == 0 {

        set i -= 1;

        set buffer[i] = '0';

    } else {

        while x <> 0 {

            set i -= 1;

            set buffer[i] = '0' + (x % 10) as u8;

            set x /= 10;

        }

        if neg {

            set i -= 1;

            set buffer[i] = '-';

        }

    }

    return i;

}

/// Write a i8 at the end of the buffer and return its start offset.

export fn formatI8(val: i8, buffer: &mut [u8]) -> u32 {

    return formatI32(val as i32, buffer);

}

/// Write a i16 at the end of the buffer and return its start offset.

export fn formatI16(val: i16, buffer: &mut [u8]) -> u32 {

    return formatI32(val as i32, buffer);

}

/// Write a u8 at the end of the buffer and return its start offset.

export fn formatU8(val: u8, buffer: &mut [u8]) -> u32 {

    return formatU32(val as u32, buffer);

}

/// Write a u16 at the end of the buffer and return its start offset.

export fn formatU16(val: u16, buffer: &mut [u8]) -> u32 {

    return formatU32(val as u32, buffer);

}

/// Write a bool at the end of the buffer and return its start offset.

export fn formatBool(val: bool, buffer: &mut [u8]) -> u32 {

    assert buffer.len >= BOOL_STR_LEN;

    if val {

        let start = buffer.len - 4;

        try! mem::copy(&mut buffer[start..], "true");

        return start;

    } else {

        let start = buffer.len - 5;

        try! mem::copy(&mut buffer[start..], "false");

        return start;

    }

}

/// Convert a single ASCII digit into its numeric value for the given radix.

export fn digitFromAscii(ch: u8, radix: u32) -> ?u32 {

    assert radix >= 2 and radix <= 36;

    // Default to an out-of-range value so non-digits fall through to `nil`.

    let mut value: u32 = 36;

    if ch >= '0' and ch <= '9' {

        set value = (ch - '0') as u32;

    } else if radix > 10 {

        // Mask to convert ASCII letters to uppercase.

        let upper = ch & 0xDF;

        if upper >= 'A' and upper <= 'Z' {

            set value = (upper - 'A') as u32 + 10;

        }

    }

    if value < radix {

        return value;

    }

    return nil;

}

/// Decode a single-byte ASCII escape.

export fn decodeAsciiEscape(ch: u8) -> u8 {

    match ch {

        case 'n'  => return '\n',

        case 't'  => return '\t',

        case 'r'  => return '\r',

        case '\\' => return '\\',

        case '"'  => return '"',

        case '\'' => return '\'',

        case '0'  => return 0,

        else      => return ch,

    }

}

/// Parse an unsigned integer literal (binary, decimal, or hexadecimal).

export fn parseInt(text: *[u8]) -> IntLiteral throws (ParseError) {

    if text.len == 0 {

        throw ParseError::Invalid;

    }

    let mut start: u32 = 0;

    let mut radix: u32 = 10;

    let mut radixType = Radix::Decimal;

    if start + 1 < text.len and text[start] == '0' {

        let prefix = text[start + 1];

        if prefix == 'x' or prefix == 'X' {

            set radix = 16;

            set radixType = Radix::Hex;

            set start += 2;

        } else if prefix == 'b' or prefix == 'B' {

            set radix = 2;

            set radixType = Radix::Binary;

            set start += 2;

        }

        if start >= text.len {

            throw ParseError::Invalid;

        }

    }

    let mut value: u64 = 0;

    let radix64: u64 = radix as u64;

    for i in start..text.len {

        let ch = text[i];

        let digit = digitFromAscii(ch, radix) else {

            throw ParseError::InvalidDigit;

        };

        if value > (U64_MAX / radix64) {

            throw ParseError::Overflow;

        }

        set value *= radix64;

        if value > U64_MAX - (digit as u64) {

            throw ParseError::Overflow;

        }

        set value += (digit as u64);

    }

    return IntLiteral { text, magnitude: value, radix: radixType };

}

/// Process escape sequences in a raw string, writing the result into `dst`.

/// Returns the number of bytes written.

export fn unescapeString(raw: *[u8], dst: &mut [u8]) -> u32 {

    let mut i: u32 = 0;

    let mut j: u32 = 0;

    while i < raw.len {

        if raw[i] == '\\' and i + 1 < raw.len {

            set dst[j] = decodeAsciiEscape(raw[i + 1]);

            set i += 2;

        } else {

            set dst[j] = raw[i];

            set i += 1;

        }

        set j += 1;

    }

    return j;

}

/// Parse a single-byte character literal, including the single quotes.

export fn parseChar(text: *[u8]) -> u8 throws (ParseError) {

    if text.len < 2 {

        throw ParseError::Invalid;

    }

    let raw = &text[1..text.len - 1];

    if raw.len == 0 {

        throw ParseError::Invalid;

    }

    if raw[0] == '\\' {

        if raw.len <> 2 {

            throw ParseError::Invalid;

        }

        return decodeAsciiEscape(raw[1]);

    }

    if raw.len <> 1 {

        throw ParseError::Invalid;

    }

    return raw[0];

}