module fasthttp

const empty_space = u8(` `)
const cr_char = u8(0x0d)
const lf_char = u8(0x0a)

// libc memchr is AVX2-accelerated via glibc IFUNC
@[inline]
fn find_byte(buf &u8, len int, c u8) int {
    unsafe {
        p := C.memchr(buf, c, len)
        if p == voidptr(nil) {
            return -1
        }
        return int(&u8(p) - buf)
    }
}

// parse_http1_request_line parses the request line of an HTTP/1.1 request.
// spec: https://datatracker.ietf.org/doc/rfc9112/
// request-line is the start-line for for requests
// According to RFC 9112, the request line is structured as:
// `request-line   = method SP request-target SP HTTP-version`
// where:
// METHOD is the HTTP method (e.g., GET, POST)
// SP is a single space character
// REQUEST-TARGET is the path or resource being requested
// HTTP-VERSION is the version of HTTP being used (e.g., HTTP/1.1)
// CRLF is a carriage return followed by a line feed
// returns the position after the CRLF on success
@[direct_array_access]
pub fn parse_http1_request_line(mut req HttpRequest) !int {
    unsafe {
        buf := &req.buffer[0]
        len := req.buffer.len

        if len < 12 {
            return error('Too short')
        }

        // METHOD
        pos1 := find_byte(buf, len, empty_space)
        if pos1 <= 0 {
            return error('Invalid method')
        }
        req.method = Slice{0, pos1}

        // PATH - skip any extra spaces
        mut pos2 := pos1 + 1
        for pos2 < len && buf[pos2] == empty_space {
            pos2++
        }
        if pos2 >= len {
            return error('Missing path')
        }

        path_start := pos2
        space_pos := find_byte(buf + pos2, len - pos2, empty_space)
        cr_pos := find_byte(buf + pos2, len - pos2, cr_char)

        if space_pos < 0 && cr_pos < 0 {
            return error('Invalid request line')
        }

        // pick earliest delimiter
        mut path_len := 0
        mut delim_pos := 0
        if space_pos >= 0 && (cr_pos < 0 || space_pos < cr_pos) {
            path_len = space_pos
            delim_pos = pos2 + space_pos
        } else {
            path_len = cr_pos
            delim_pos = pos2 + cr_pos
        }

        req.path = Slice{path_start, path_len}

        // VERSION
        if buf[delim_pos] == cr_char {
            // No HTTP version specified
            req.version = Slice{delim_pos, 0}
        } else {
            version_start := delim_pos + 1
            cr := find_byte(buf + version_start, len - version_start, cr_char)
            if cr < 0 {
                return error('Invalid HTTP request line: Missing CR')
            }
            req.version = Slice{version_start, cr}
            delim_pos = version_start + cr
        }

        // Validate CRLF
        if delim_pos + 1 >= len || buf[delim_pos + 1] != lf_char {
            return error('Invalid CRLF')
        }

        return delim_pos + 2 // Return position after CRLF
    }
}

// decode_http_request parses a raw HTTP request from the given byte buffer
pub fn decode_http_request(buffer []u8) !HttpRequest {
    mut req := HttpRequest{
        buffer: buffer
    }

    // header_start is the byte index immediately after the request line's \r\n
    header_start := parse_http1_request_line(mut req)!

    // Find the end of the header block (\r\n\r\n)
    mut body_start := -1
    for i := header_start; i <= buffer.len - 4; i++ {
        if buffer[i] == cr_char && buffer[i + 1] == lf_char && buffer[i + 2] == cr_char
            && buffer[i + 3] == lf_char {
            body_start = i + 4

            // The header fields slice covers everything from header_start
            // up to (but not including) the final double CRLF
            req.header_fields = Slice{
                start: header_start
                len:   i - header_start
            }
            break
        }
    }

    if body_start != -1 {
        req.body = Slice{
            start: body_start
            len:   buffer.len - body_start
        }
    } else {
        // If no body delimiter found, assume headers go to end or body is missing
        req.header_fields = Slice{header_start, buffer.len - header_start - 2}
        req.body = Slice{0, 0}
    }

    return req
}

// Helper function to convert Slice to string for debugging
fn (slice Slice) to_string(buffer []u8) string {
    if slice.len <= 0 {
        return ''
    }
    return buffer[slice.start..slice.start + slice.len].bytestr()
}

@[direct_array_access]
fn find_header_end_in_buf(buf &u8, buf_len int) int {
    for i := 0; i < buf_len - 1; i++ {
        unsafe {
            if buf[i] == `\n` {
                if i + 1 < buf_len && buf[i + 1] == `\n` {
                    return i + 2
                }
                if i + 2 < buf_len && buf[i + 1] == `\r` && buf[i + 2] == `\n` {
                    return i + 3
                }
            }
            if i + 3 < buf_len && buf[i] == `\r` && buf[i + 1] == `\n` && buf[i + 2] == `\r`
                && buf[i + 3] == `\n` {
                return i + 4
            }
        }
    }
    return -1
}

// has_complete_body checks if a raw HTTP request buffer contains the full body
// as indicated by the Content-Length or Transfer-Encoding headers. Returns true if:
//   - there is no Content-Length header and no chunked encoding (body not expected)
//   - Content-Length is 0
//   - enough body bytes have been received
//   - chunked encoding is complete (the zero-size chunk and trailers were parsed)
// Returns false only when more body data is expected.
@[direct_array_access]
fn has_complete_body(buf &u8, buf_len int) bool {
    header_end := find_header_end_in_buf(buf, buf_len)
    if header_end < 0 {
        return false // headers not complete yet
    }
    // Check for Transfer-Encoding: chunked header (case-insensitive)
    if has_chunked_transfer_encoding_in_buf(buf, header_end) {
        return has_complete_chunked_body(buf, buf_len, header_end)
    }
    content_length := parse_content_length_from_buf(buf, header_end)
    if content_length <= 0 {
        return true // no content-length or zero: body complete
    }
    body_received := buf_len - header_end
    return body_received >= content_length
}

@[direct_array_access]
fn has_complete_chunked_body(buf &u8, buf_len int, body_start int) bool {
    mut pos := body_start
    for {
        lf_pos := find_line_lf_in_buf(buf, buf_len, pos)
        if lf_pos < 0 {
            return false
        }
        mut line_end := lf_pos
        unsafe {
            if line_end > pos && buf[line_end - 1] == `\r` {
                line_end--
            }
        }
        mut size_end := line_end
        for i := pos; i < line_end; i++ {
            unsafe {
                if buf[i] == `;` {
                    size_end = i
                    break
                }
            }
        }
        mut size_start := pos
        for size_start < size_end {
            unsafe {
                if buf[size_start] != ` ` && buf[size_start] != `\t` {
                    break
                }
            }
            size_start++
        }
        for size_end > size_start {
            unsafe {
                if buf[size_end - 1] != ` ` && buf[size_end - 1] != `\t` {
                    break
                }
            }
            size_end--
        }
        if size_start == size_end {
            return true
        }
        mut chunk_size := 0
        for i := size_start; i < size_end; i++ {
            digit := chunked_hex_digit_value(unsafe { buf[i] })
            if digit < 0 {
                return true
            }
            if chunk_size > (max_int - digit) / 16 {
                return true
            }
            chunk_size = chunk_size * 16 + digit
        }
        pos = lf_pos + 1
        if chunk_size == 0 {
            return has_complete_chunked_trailers(buf, buf_len, pos)
        }
        if chunk_size > buf_len - pos {
            return false
        }
        data_end := pos + chunk_size
        if data_end + 2 > buf_len {
            return false
        }
        unsafe {
            if buf[data_end] != `\r` || buf[data_end + 1] != `\n` {
                return true
            }
        }
        pos = data_end + 2
    }
    return false
}

@[direct_array_access]
fn has_complete_chunked_trailers(buf &u8, buf_len int, start int) bool {
    mut pos := start
    for {
        lf_pos := find_line_lf_in_buf(buf, buf_len, pos)
        if lf_pos < 0 {
            return false
        }
        mut line_end := lf_pos
        unsafe {
            if line_end > pos && buf[line_end - 1] == `\r` {
                line_end--
            }
        }
        if line_end == pos {
            return true
        }
        pos = lf_pos + 1
    }
    return false
}

@[direct_array_access]
fn find_line_lf_in_buf(buf &u8, buf_len int, start int) int {
    for i := start; i < buf_len; i++ {
        unsafe {
            if buf[i] == `\n` {
                return i
            }
        }
    }
    return -1
}

fn chunked_hex_digit_value(ch u8) int {
    if ch >= `0` && ch <= `9` {
        return int(ch - `0`)
    }
    if ch >= `a` && ch <= `f` {
        return int(ch - `a` + 10)
    }
    if ch >= `A` && ch <= `F` {
        return int(ch - `A` + 10)
    }
    return -1
}

// has_chunked_transfer_encoding_in_buf scans the header bytes for a
// "Transfer-Encoding:" header whose value contains "chunked" (case-insensitive).
@[direct_array_access]
fn has_chunked_transfer_encoding_in_buf(buf &u8, header_end int) bool {
    te_lower := 'transfer-encoding:'
    for i := 0; i < header_end - te_lower.len; i++ {
        unsafe {
            if buf[i] != `\n` {
                continue
            }
            pos := i + 1
            if pos + te_lower.len > header_end {
                continue
            }
            mut matched := true
            for j := 0; j < te_lower.len; j++ {
                mut ch := buf[pos + j]
                if ch >= `A` && ch <= `Z` {
                    ch = ch + 32
                }
                if ch != te_lower[j] {
                    matched = false
                    break
                }
            }
            if matched {
                chunked_str := 'chunked'
                for val_start := pos + te_lower.len; val_start < header_end - chunked_str.len; val_start++ {
                    if buf[val_start] == `\r` || buf[val_start] == `\n` {
                        break
                    }
                    mut cmatch := true
                    for k := 0; k < chunked_str.len; k++ {
                        mut ch2 := buf[val_start + k]
                        if ch2 >= `A` && ch2 <= `Z` {
                            ch2 = ch2 + 32
                        }
                        if ch2 != chunked_str[k] {
                            cmatch = false
                            break
                        }
                    }
                    if cmatch {
                        return true
                    }
                }
            }
        }
    }
    return false
}

// parse_content_length_from_buf scans the header bytes for a Content-Length header
// and returns its integer value, or -1 if not found.
@[direct_array_access]
fn parse_content_length_from_buf(buf &u8, header_end int) int {
    cl_lower := 'content-length:'
    for i := 0; i < header_end - cl_lower.len; i++ {
        unsafe {
            if buf[i] != `\n` {
                continue
            }
            pos := i + 1
            if pos + cl_lower.len > header_end {
                continue
            }
            mut matched := true
            for j := 0; j < cl_lower.len; j++ {
                mut ch := buf[pos + j]
                if ch >= `A` && ch <= `Z` {
                    ch = ch + 32
                }
                if ch != cl_lower[j] {
                    matched = false
                    break
                }
            }
            if matched {
                mut start := pos + cl_lower.len
                for start < header_end && buf[start] == ` ` {
                    start++
                }
                mut val := 0
                for start < header_end && buf[start] >= `0` && buf[start] <= `9` {
                    val = val * 10 + int(buf[start] - `0`)
                    start++
                }
                return val
            }
        }
    }
    return -1
}