// Copyright (c) 2019-2026 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module s3

// uri_encode performs RFC 3986 percent-encoding as required by Signature V4.
// Only the unreserved set A–Z / a–z / 0–9 / '-' / '_' / '.' / '~' is preserved.
// When `encode_slash` is false (used for object keys), '/' is left intact and
// backslashes are normalized to '/' so Windows-style paths produce the same
// canonical key. All other bytes are emitted as %XX with uppercase hex digits.
pub fn uri_encode(input string, encode_slash bool) string {
    mut out := []u8{cap: input.len + (input.len >> 2)} // 25% headroom
    for b in input.bytes() {
        match b {
            `A`...`Z`, `a`...`z`, `0`...`9`, `-`, `_`, `.`, `~` {
                out << b
            }
            `/`, `\\` {
                if encode_slash {
                    append_percent(mut out, b)
                } else {
                    out << if b == `\\` { u8(`/`) } else { b }
                }
            }
            else {
                append_percent(mut out, b)
            }
        }
    }
    return out.bytestr()
}

// uri_encode_path encodes an S3 object key segment-aware: '/' is preserved
// because S3 paths use it as the segment separator.
@[inline]
pub fn uri_encode_path(path string) string {
    return uri_encode(path, false)
}

// uri_encode_query encodes a value that will appear inside a query string.
// Slashes must be percent-encoded.
@[inline]
pub fn uri_encode_query(value string) string {
    return uri_encode(value, true)
}

// strip_slashes removes leading and trailing '/' or '\\' separators. S3
// canonical paths must contain a single leading slash, no trailing one.
pub fn strip_slashes(s string) string {
    if s == '' {
        return s
    }
    mut start := 0
    mut end := s.len
    for start < end && (s[start] == `/` || s[start] == `\\`) {
        start++
    }
    for end > start && (s[end - 1] == `/` || s[end - 1] == `\\`) {
        end--
    }
    return s[start..end]
}

// contains_crlf returns true if `value` contains a CR or LF byte. Header
// values that pass user-provided strings (ACL, content-type, …) MUST be
// checked to prevent HTTP header injection (CRLF smuggling).
@[inline]
pub fn contains_crlf(value string) bool {
    for b in value.bytes() {
        if b == `\r` || b == `\n` {
            return true
        }
    }
    return false
}

// to_hex_lower formats raw bytes as their lowercase hex string. Used for
// SHA-256 digests inside SigV4 (the spec requires lowercase).
pub fn to_hex_lower(data []u8) string {
    mut out := []u8{len: data.len * 2}
    for i, b in data {
        out[i * 2] = hex_lower_nibble(b >> 4)
        out[i * 2 + 1] = hex_lower_nibble(b & 0x0F)
    }
    return out.bytestr()
}

@[inline]
fn append_percent(mut out []u8, b u8) {
    out << `%`
    out << hex_upper_nibble(b >> 4)
    out << hex_upper_nibble(b & 0x0F)
}

@[inline]
fn hex_upper_nibble(n u8) u8 {
    return if n < 10 { n + `0` } else { n - 10 + `A` }
}

@[inline]
fn hex_lower_nibble(n u8) u8 {
    return if n < 10 { n + `0` } else { n - 10 + `a` }
}