// Copyright (c) 2019-2024 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 veb

import fasthttp
import net.http
import strconv
import strings
import time
import net.urllib

struct RequestParams {
    global_app                voidptr
    controllers_sorted        []&ControllerPath
    routes                    &map[string]Route
    benchmark_page_generation bool
}

const http_ok_response = 'HTTP/1.1 200 OK\r\nContent-Type: application/json\r\nContent-Length: 0\r\nConnection: keep-alive\r\n\r\n'.bytes()

pub fn run_at[A, X](mut global_app A, params RunParams) ! {
    run_new[A, X](mut global_app, params)!
}

// run_new - start a new veb server using the parallel fasthttp backend.
pub fn run_new[A, X](mut global_app A, params RunParams) ! {
    if params.port <= 0 || params.port > 65535 {
        return error('invalid port number `${params.port}`, it should be between 1 and 65535')
    }
    if ssl_enabled(params) {
        maybe_init_server[A](mut global_app, new_server_without_lifecycle())
        run_at_with_ssl[A, X](mut global_app, params)!
        return
    }

    // Generate routes and controllers just like the original run() function.
    routes := generate_routes[A, X](global_app)!
    controllers_sorted := check_duplicate_routes_in_controllers[A](global_app, routes)!

    // Allocate params on the heap to keep it valid for the server lifetime
    request_params := &RequestParams{
        global_app:                unsafe { voidptr(&global_app) }
        controllers_sorted:        controllers_sorted
        routes:                    &routes
        benchmark_page_generation: params.benchmark_page_generation
    }

    // Configure and run the fasthttp server
    mut server := fasthttp.new_server(fasthttp.ServerConfig{
        family:                  params.family
        port:                    params.port
        handler:                 parallel_request_handler[A, X]
        max_request_buffer_size: params.max_request_buffer_size
        timeout_in_seconds:      params.timeout_in_seconds
        user_data:               voidptr(request_params)
    }) or {
        eprintln('Failed to create server: ${err}')
        return
    }
    handle := server.handle()
    maybe_init_server[A](mut global_app, new_server_with_lifecycle(handle))
    println('[veb] Running multi-threaded app on ${server_protocol(params)}://${startup_host(params)}:${params.port}/')
    flush_stdout()
    $if A is BeforeAcceptApp {
        mut server_thread := spawn_fasthttp_server_run(mut server)
        // Wait until the listener is bound before invoking before_accept_loop,
        // so callers using `<-app.started` actually see the server ready.
        handle.wait_till_running() or {}
        global_app.before_accept_loop()
        server_thread.wait() or { panic(err) }
    } $else {
        server.run() or { panic(err) }
    }
}

fn spawn_fasthttp_server_run(mut server fasthttp.Server) thread ! {
    return spawn server.run()
}

fn parallel_request_handler[A, X](req fasthttp.HttpRequest) !fasthttp.HttpResponse {
    // Get parameters from user_data - copy to avoid use-after-free
    params := unsafe { *(&RequestParams(req.user_data)) }
    mut global_app := unsafe { &A(params.global_app) }

    client_fd := req.client_conn_fd

    head_end := if req.body.start > 0 { req.body.start } else { req.buffer.len }
    head := req.buffer[..head_end].bytestr()
    // Parse the request head into a standard `http.Request`, then copy just the body.
    mut req2 := http.parse_request_head_str(head) or {
        return fasthttp.HttpResponse{
            content:       'HTTP/1.1 500 Internal Server Error\r\nContent-Length: 0\r\nConnection: close\r\n\r\n'.bytes()
            content_owned: true
        }
    }
    $if trace_prealloc ? {
        unsafe { prealloc_scope_checkpoint(c'veb parsed http head') }
    }
    if req.body.len > 0 {
        req2.data = req.buffer[req.body.start..req.body.start + req.body.len].bytestr()
    }
    // If the request uses chunked transfer encoding, decode the chunked body
    if transfer_encoding_is_chunked(req2.header) {
        req2.data = decode_chunked_body(req2.data) or {
            return fasthttp.HttpResponse{
                content:       'HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n'.bytes()
                content_owned: true
            }
        }
    }
    if invalid_resp := content_length_validation_response(req, req2) {
        return invalid_resp
    }
    // Create and populate the `veb.Context`.
    mut completed_context := handle_request_and_route[A, X](mut global_app, req2, client_fd, params)
    $if trace_prealloc ? {
        unsafe { prealloc_scope_checkpoint(c'veb handled route') }
    }

    match completed_context.takeover_mode {
        .manual {
            // The handler has taken over the connection (e.g. for SSE or WebSocket).
            // The response was already sent directly over ctx.conn.
            // Tell fasthttp to hand off the fd without closing it.
            return fasthttp.HttpResponse{
                takeover_mode: .manual
            }
        }
        .reusable {
            should_close := should_close_connection(completed_context.req, completed_context.res,
                completed_context.client_wants_to_close)
            return fasthttp.HttpResponse{
                takeover_mode: .reusable
                should_close:  should_close
            }
        }
        .none {}
    }

    should_close := should_close_connection(completed_context.req, completed_context.res,
        completed_context.client_wants_to_close)
    content := completed_context.res.bytes()
    $if trace_prealloc ? {
        unsafe { prealloc_scope_checkpoint(c'veb serialized response') }
    }
    unsafe { completed_context.res.body.free() }
    completed_context.res.body = ''
    return_type := completed_context.return_type
    return_file := completed_context.return_file
    unsafe { free(completed_context) }

    if return_type == .file {
        return fasthttp.HttpResponse{
            content:       content
            content_owned: true
            file_path:     return_file
            should_close:  should_close
        }
    }

    // The fasthttp server expects a complete response buffer to be returned.
    return fasthttp.HttpResponse{
        content:       content
        content_owned: true
        should_close:  should_close
    }
} // handle_request_and_route is a unified function that creates the context,

fn content_length_validation_response(req fasthttp.HttpRequest, parsed http.Request) ?fasthttp.HttpResponse {
    if transfer_encoding_is_chunked(parsed.header) {
        return none
    }
    content_length := parsed.header.get(.content_length) or { return none }
    expected_length := content_length.int()
    actual_length := req.body.len
    if actual_length == expected_length {
        return none
    }
    if actual_length < expected_length {
        return fasthttp.HttpResponse{
            content:       http_408.bytes()
            content_owned: true
        }
    }
    return fasthttp.HttpResponse{
        content:       http.new_response(
            status: .bad_request
            body:   'Mismatch of body length and Content-Length header'
            header: http.new_header(
                key:   .content_type
                value: 'text/plain'
            ).join(headers_close)
        ).bytes()
        content_owned: true
    }
}

// runs middleware, and finds the correct route for a request.
fn handle_request_and_route[A, X](mut app A, req http.Request, _client_fd int, params RequestParams) &Context {
    // Create and populate the `veb.Context` from the request.
    mut url := urllib.parse_request_uri(req.url) or {
        // This should be rare if http.parse_request succeeded.
        mut bad_ctx := &Context{
            req: req
        }
        bad_ctx.not_found()
        return bad_ctx
    }
    query := parse_query_from_url(url)
    form, files := parse_form_from_request(req) or {
        mut bad_ctx := &Context{
            req: req
        }
        bad_ctx.request_error('Failed to parse form data: ${err.msg()}')
        return bad_ctx
    }
    $if trace_prealloc ? {
        unsafe { prealloc_scope_checkpoint(c'veb parsed url/form') }
    }
    host_with_port := req.header.get(.host) or { '' }
    host := request_host_name(host_with_port)
    page_gen_start := if params.benchmark_page_generation { time.ticks() } else { 0 }
    $if trace_prealloc ? {
        unsafe { prealloc_scope_checkpoint(c'veb parsed host') }
    }
    mut ctx := &Context{
        req:                   req
        page_gen_start:        page_gen_start
        client_fd:             _client_fd
        client_wants_to_close: request_has_connection_close(req)
        query:                 query
        form:                  form
        files:                 files
    }
    mut user_context := X{
        Context: ctx
    }
    $if trace_prealloc ? {
        unsafe { prealloc_scope_checkpoint(c'veb context initialized') }
    }
    $if A is StaticApp {
        ctx.custom_mime_types_ref = unsafe { &app.static_mime_types }
        if serve_if_static[X](static_handler_config(app.static_files, app.static_mime_types,
            app.static_hosts, app.static_prefixes, app.enable_static_gzip, app.enable_static_zstd,
            app.enable_static_compression, app.static_compression_max_size,
            app.static_compression_mime_types, app.enable_markdown_negotiation), mut user_context,
            url, host)
        {
            // Preserve the handled context on the heap before the stack-local user context goes away.
            unsafe {
                *ctx = user_context.Context
            }
            return ctx
        }
    }
    $if trace_prealloc ? {
        unsafe { prealloc_scope_checkpoint(c'veb pre-route static checked') }
    }
    // Match controller paths first
    $if A is ControllerInterface {
        if completed_context := handle_controllers[X](params.controllers_sorted, ctx, mut url, host) {
            return completed_context
        }
    }
    // Create a new user context and pass veb's context
    handle_route[A, X](mut app, mut user_context, url, host, params.routes)
    $if trace_prealloc ? {
        unsafe { prealloc_scope_checkpoint(c'veb route returned') }
    }
    // Preserve the handled context on the heap before the stack-local user context goes away.
    unsafe {
        *ctx = user_context.Context
    }
    return ctx
}

// decode_chunked_body decodes a chunked transfer-encoded body string
// into the raw body content.
fn decode_chunked_body(data string) !string {
    mut sb := strings.new_builder(data.len)
    mut pos := 0
    for pos < data.len {
        // Find the end of the chunk size line
        line_end := data.index_after_('\r\n', pos)
        if line_end == -1 {
            return error('invalid chunked body: missing chunk size line ending')
        }
        chunk_size_str := data[pos..line_end].all_before(';').trim_space()
        if chunk_size_str.len == 0 {
            return error('invalid chunked body: empty chunk size')
        }
        chunk_size := int(strconv.parse_uint(chunk_size_str, 16, 64) or {
            return error('invalid chunked body: bad chunk size')
        })
        pos = line_end + 2 // skip past \r\n
        if chunk_size == 0 {
            // Terminal chunk - skip trailers
            break
        }
        if pos + chunk_size > data.len {
            return error('invalid chunked body: chunk data truncated')
        }
        sb.write_string(data[pos..pos + chunk_size])
        pos += chunk_size + 2 // skip chunk data + \r\n delimiter
    }
    return sb.str()
}