module hex

const hex_digits = '0123456789abcdef'
const hex_digits_upper = '0123456789ABCDEF'

// EncodeParams configures optional output formatting for encode.
//
// If `uppercase` is set, `encode` emits `A-F` instead of `a-f`.
// If `with_prefix` is non-empty, `encode` prepends that exact string.
@[params]
pub struct EncodeParams {
pub mut:
	uppercase   bool
	with_prefix string
}

// decode converts a hex string into an array of bytes.
// The expected input format is 2 ASCII characters for each output byte.
// If the provided string length is not a multiple of 2, the first digit is
// decoded as if an implicit `0` preceded it. An optional `0x` or `0X` prefix
// is accepted.
@[direct_array_access]
pub fn decode(s string) ![]u8 {
	if s.len == 0 {
		return []u8{}
	}

	mut offset := 0
	mut hex_bytes := if s.len >= 2 {
		if s[0] == `0` && (s[1] == `x` || s[1] == `X`) {
			offset = 2
			s[2..].bytes()
		} else {
			s.bytes()
		}
	} else {
		s.bytes()
	}

	if hex_bytes.len == 0 {
		return []u8{}
	}

	mut bytes := []u8{cap: (hex_bytes.len + 1) >> 1}
	mut start := 0
	if hex_bytes.len & 1 == 1 {
		bytes << char2nibble(hex_bytes[0], offset)!
		start = 1
	}

	for i := start; i < hex_bytes.len; i += 2 {
		n1 := char2nibble(hex_bytes[i], offset + i)!
		n0 := char2nibble(hex_bytes[i + 1], offset + i + 1)!
		bytes << (n1 << 4) | n0
	}
	return bytes
}

// encode converts an array of bytes into a string of ASCII hex bytes. The
// output will always be a string whose length will be a multiple of 2.
// If `EncodeParams.uppercase` is set, the output hex characters are emitted in
// uppercase.
// If `EncodeParams.with_prefix` is non-empty, the output string is prefixed
// with the provided string.
@[direct_array_access]
pub fn encode(bytes []u8, params EncodeParams) string {
	if bytes.len == 0 {
		return ''
	}
	mut res := []u8{}
	if params.with_prefix != '' {
		res << params.with_prefix.bytes()
	}
	for _, b in bytes {
		res << nibble2char(b >> 4, params)
		res << nibble2char(b & 0xf, params)
	}
	return res.bytestr()
}

// nibble2char converts a 4-bit hex value to its ASCII character
@[inline]
fn nibble2char(nibble u8, params EncodeParams) u8 {
	if params.uppercase {
		return hex_digits_upper[nibble]
	}
	return hex_digits[nibble]
}

// char2nibble converts an ASCII hex character to its hex value
@[inline]
fn char2nibble(b u8, index int) !u8 {
	match b {
		`0`...`9` { return b - u8(`0`) }
		`A`...`F` { return b - u8(`A`) + 10 }
		`a`...`f` { return b - u8(`a`) + 10 }
		else { return error('invalid hex char ${b.ascii_str()} at index ${index}') }
	}
}