// Copyright (c) 2019-2025 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 fasthttp

import runtime
import net
import time

#include <errno.h>

$if !windows {
    #include <fcntl.h>
    #include <sys/socket.h>
    #include <netinet/in.h>
    #include <netinet/tcp.h>
}

const max_thread_pool_size = runtime.nr_cpus()
const max_connection_size = 65536 // Max events per epoll_wait

const tiny_bad_request_response = 'HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n'.bytes()
const status_444_response = 'HTTP/1.1 444 No Response\r\nContent-Length: 0\r\nConnection: close\r\n\r\n'.bytes()
const status_413_response = 'HTTP/1.1 413 Payload Too Large\r\nContent-Length: 0\r\nConnection: close\r\n\r\n'.bytes()

fn C.socket(domain i32, typ i32, protocol i32) i32

fn C.bind(sockfd i32, addr &net.Addr, addrlen u32) i32

fn C.send(__fd i32, __buf voidptr, __n usize, __flags i32) i32

fn C.recv(__fd i32, __buf voidptr, __n usize, __flags i32) i32

fn C.setsockopt(__fd i32, __level i32, __optname i32, __optval voidptr, __optlen u32) i32

fn C.listen(__fd i32, __n i32) i32

fn C.perror(s &u8)

fn C.close(fd i32) i32

fn C.htons(__hostshort u16) u16

fn C.fcntl(fd i32, cmd i32, arg i32) i32

pub struct Slice {
pub:
    start int
    len   int
}

// HttpRequest represents an HTTP request.
// TODO make fields immutable
pub struct HttpRequest {
pub mut:
    buffer         []u8 // A V slice of the read buffer for convenience
    method         Slice
    path           Slice
    version        Slice
    header_fields  Slice
    body           Slice
    client_conn_fd int
    user_data      voidptr // User-defined context data
}

pub enum ResponseTakeoverMode {
    none
    manual
    reusable
}

pub struct HttpResponse {
pub mut:
    content       []u8
    file_path     string
    takeover_mode ResponseTakeoverMode
    should_close  bool // if true, close the connection after sending (Connection: close)
    // content_owned lets the backend free or move content after it has been sent.
    content_owned bool
    // request_arena is a prealloc scope handle that must be freed after sending.
    request_arena voidptr
}

fn (mut resp HttpResponse) free_owned_content() {
    if resp.content_owned && resp.content.cap > 0 {
        unsafe { resp.content.free() }
        resp.content = []u8{}
    }
}

fn (mut resp HttpResponse) take_or_clone_content() []u8 {
    if resp.content_owned {
        content := resp.content
        resp.content = []u8{}
        return content
    }
    return resp.content.clone()
}

fn end_request_arena_current_thread(request_arena voidptr) {
    $if prealloc {
        if request_arena != unsafe { nil } {
            unsafe { prealloc_scope_end(request_arena) }
        }
    }
}

fn leave_request_arena_current_thread(request_arena voidptr) {
    $if prealloc {
        if request_arena != unsafe { nil } {
            unsafe { prealloc_scope_leave(request_arena) }
        }
    }
}

fn abandon_request_arena_current_thread(request_arena voidptr) {
    $if prealloc {
        if request_arena != unsafe { nil } {
            unsafe { prealloc_scope_abandon(request_arena) }
        }
    }
}

fn (mut resp HttpResponse) attach_request_arena_if_empty(request_arena voidptr) {
    if resp.request_arena == unsafe { nil } {
        resp.request_arena = request_arena
    }
}

fn (mut resp HttpResponse) end_request_arena_current_thread() {
    end_request_arena_current_thread(resp.request_arena)
    resp.request_arena = unsafe { nil }
}

fn (mut resp HttpResponse) abandon_request_arena_current_thread() {
    abandon_request_arena_current_thread(resp.request_arena)
    resp.request_arena = unsafe { nil }
}

fn (mut resp HttpResponse) take_request_arena() voidptr {
    request_arena := resp.request_arena
    resp.request_arena = unsafe { nil }
    return request_arena
}

// ServerConfig bundles the parameters needed to start a fasthttp server.
pub struct ServerConfig {
pub:
    family                  net.AddrFamily = .ip6
    port                    int            = 3000
    max_request_buffer_size int            = 8192
    timeout_in_seconds      int            = 30
    handler                 fn (HttpRequest) !HttpResponse @[required]
    user_data               voidptr
}

// ShutdownParams configures how long graceful shutdown should wait for in-flight requests.
@[params]
pub struct ShutdownParams {
pub:
    timeout         time.Duration = time.infinite
    retry_period_ms int           = 10
}

// WaitTillRunningParams allows parametrizing the calls to `ServerHandle.wait_till_running()`.
@[params]
pub struct WaitTillRunningParams {
pub:
    max_retries     int = 100
    retry_period_ms int = 10
}

// ServerHandle exposes lifecycle controls for a running `fasthttp.Server`.
pub struct ServerHandle {
    ptr voidptr
}

// handle returns a reusable handle for waiting on or shutting down the server.
pub fn (s &Server) handle() ServerHandle {
    return ServerHandle{
        ptr: s
    }
}

// wait_till_running waits until the server transitions to its serving state.
pub fn (h ServerHandle) wait_till_running(params WaitTillRunningParams) !int {
    if h.ptr == unsafe { nil } {
        return error('server handle is not initialized')
    }
    $if linux || bsd {
        mut server := unsafe { &Server(h.ptr) }
        return server.wait_till_running_impl(params)!
    } $else {
        return error('fasthttp server lifecycle control is only supported on linux and BSD-family OSes')
    }
}

// shutdown gracefully stops accepting new requests and waits for active requests to finish.
pub fn (h ServerHandle) shutdown(params ShutdownParams) ! {
    if h.ptr == unsafe { nil } {
        return error('server handle is not initialized')
    }
    $if linux || bsd {
        mut server := unsafe { &Server(h.ptr) }
        server.shutdown_impl(params)!
    } $else {
        return error('fasthttp server lifecycle control is only supported on linux and BSD-family OSes')
    }
}

$if linux || bsd {
    fn normalized_retry_period_ms(retry_period_ms int) int {
        return if retry_period_ms > 0 { retry_period_ms } else { 1 }
    }

    fn (mut s Server) wait_till_running_impl(params WaitTillRunningParams) !int {
        retry_period_ms := normalized_retry_period_ms(params.retry_period_ms)
        mut attempts := 0
        mut running := s.running
        for !running.load() && attempts < params.max_retries {
            time.sleep(retry_period_ms * time.millisecond)
            attempts++
        }
        if !running.load() {
            return error('maximum retries reached')
        }
        time.sleep(retry_period_ms * time.millisecond)
        return attempts
    }

    fn (mut s Server) shutdown_impl(params ShutdownParams) ! {
        mut stopped := s.stopped
        if stopped.load() {
            return
        }
        mut shutting_down := s.shutting_down
        if shutting_down.compare_and_swap(false, true) {
            s.stop_accepting()
        }
        retry_period_ms := normalized_retry_period_ms(params.retry_period_ms)
        mut watch := time.new_stopwatch()
        for !stopped.load() {
            if params.timeout != time.infinite && watch.elapsed() >= params.timeout {
                return error('graceful shutdown timed out after ${params.timeout}')
            }
            time.sleep(retry_period_ms * time.millisecond)
        }
    }

    fn (s &Server) begin_request() {
        mut active_requests := s.active_requests
        active_requests.add(1)
    }

    fn (s &Server) end_request() {
        mut active_requests := s.active_requests
        active_requests.sub(1)
    }

    fn (s &Server) active_request_count() int {
        mut active_requests := s.active_requests
        return active_requests.load()
    }

    fn (s &Server) is_shutting_down() bool {
        mut shutting_down := s.shutting_down
        return shutting_down.load()
    }

    fn (s &Server) is_stopped() bool {
        mut stopped := s.stopped
        return stopped.load()
    }

    fn (mut s Server) mark_running() {
        mut running := s.running
        running.store(true)
        mut stopped := s.stopped
        stopped.store(false)
    }

    fn (mut s Server) mark_stopped() {
        mut active_requests := s.active_requests
        active_requests.store(0)
        mut running := s.running
        running.store(false)
        mut stopped := s.stopped
        stopped.store(true)
    }
}