module veb

import io
import net
import net.http
import net.mbedtls
import os
import time

@[params]
pub struct RunParams {
pub:
    // use `family: .ip, host: 'localhost'` when you want it to bind only to 127.0.0.1
    family                    net.AddrFamily = .ip6
    host                      string
    port                      int  = default_port
    nr_workers                int  = 1
    show_startup_message      bool = true
    timeout_in_seconds        int  = 30
    max_request_buffer_size   int  = 8192
    benchmark_page_generation bool // for the "page rendered in X ms"
    ssl_config                mbedtls.SSLConnectConfig
}

fn run_at_with_ssl[A, X](mut global_app A, params RunParams) ! {
    routes := generate_routes[A, X](global_app)!
    controllers_sorted := check_duplicate_routes_in_controllers[A](global_app, routes)!
    if params.show_startup_message {
        println('[veb] Running app on https://${startup_host(params)}:${params.port}/')
    }
    flush_stdout()
    mut ssl_listener := mbedtls.new_ssl_listener(listen_addr(params), params.ssl_config)!
    defer {
        ssl_listener.shutdown() or {}
    }
    ssl_params := &SslRequestParams{
        global_app:                unsafe { voidptr(&global_app) }
        controllers_sorted:        controllers_sorted
        routes:                    &routes
        benchmark_page_generation: params.benchmark_page_generation
        max_request_buffer_size:   if params.max_request_buffer_size > 0 {
            params.max_request_buffer_size
        } else {
            max_read
        }
    }
    $if A is BeforeAcceptApp {
        global_app.before_accept_loop()
    }
    for {
        mut ssl_conn := ssl_listener.accept() or {
            eprintln('[veb] accept() failed, reason: ${err}; skipping')
            continue
        }
        ssl_conn.duration = params.timeout_in_seconds * time.second
        spawn handle_ssl_connection[A, X](mut ssl_conn, ssl_params)
    }
}

fn handle_ssl_connection[A, X](mut ssl_conn mbedtls.SSLConn, params &SslRequestParams) {
    defer {
        ssl_conn.shutdown() or {}
    }
    mut reader := io.new_buffered_reader(
        reader: ssl_conn
        cap:    params.max_request_buffer_size
    )
    defer {
        unsafe {
            reader.free()
        }
    }
    for {
        req := read_request_from_buffered_reader(mut reader) or {
            if err !is io.Eof {
                write_ssl_response(mut ssl_conn, http_400) or {}
            }
            return
        }
        completed_context := handle_ssl_request[A, X](req, params) or {
            write_ssl_response(mut ssl_conn, http_400) or {}
            return
        }
        if completed_context.takeover_mode != .none {
            eprintln('[veb] HTTPS connections do not support takeover connections yet; closing the connection after this response.')
        }
        write_ssl_context_response(mut ssl_conn, completed_context) or {
            eprintln('[veb] error sending HTTPS response: ${err}')
            return
        }
        if completed_context.takeover_mode != .none
            || should_close_connection(completed_context.req, completed_context.res, completed_context.client_wants_to_close) {
            return
        }
    }
}

fn write_ssl_context_response(mut ssl_conn mbedtls.SSLConn, completed_context &Context) ! {
    if !completed_context.done && completed_context.return_type == .normal {
        return error('context did not send a response')
    }
    match completed_context.return_type {
        .normal {
            write_ssl_response(mut ssl_conn, completed_context.res)!
        }
        .file {
            write_ssl_response(mut ssl_conn, completed_context.res)!
            if completed_context.return_file == '' {
                return error('missing file response path')
            }
            mut file := os.open(completed_context.return_file)!
            defer {
                file.close()
            }
            mut buf := []u8{len: max_read}
            for {
                n := file.read(mut buf) or {
                    if err is io.Eof {
                        break
                    }
                    return err
                }
                if n <= 0 {
                    break
                }
                ssl_conn.write(buf[..n])!
            }
        }
    }
}

fn write_ssl_response(mut ssl_conn mbedtls.SSLConn, resp http.Response) ! {
    ssl_conn.write(resp.bytes())!
}