module fasthttp

import net
import os
import time

const fasthttp_example_exe = os.join_path(os.cache_dir(), 'fasthttp_example_test.exe')
const reusable_takeover_port = 13019
const reusable_takeover_addr = '127.0.0.1:${reusable_takeover_port}'

fn testsuite_begin() {
    // Clean up old example binary if it exists
    if os.exists(fasthttp_example_exe) {
        os.rm(fasthttp_example_exe) or {}
    }
}

fn test_fasthttp_example_compiles() {
    vexe := os.getenv('VEXE')
    vroot := os.dir(vexe)

    // Build the fasthttp example
    build_result := os.system('${os.quoted_path(vexe)} -o ${os.quoted_path(fasthttp_example_exe)} ${os.join_path(vroot,
        'examples', 'fasthttp')}')
    assert build_result == 0, 'fasthttp example failed to compile'
    assert os.exists(fasthttp_example_exe), 'fasthttp example binary not found after build'
}

fn test_parse_request_line() {
    // Test basic GET request
    request := 'GET / HTTP/1.1\r\n'.bytes()
    req := decode_http_request(request) or {
        assert false, 'Failed to parse valid request: ${err}'
        return
    }

    assert req.buffer.len == request.len
    assert req.method.start == 0
    assert req.method.len == 3
    assert req.path.start == 4
    assert req.path.len == 1
    assert req.version.start == 6
    assert req.version.len == 8

    method := req.buffer[req.method.start..req.method.start + req.method.len].bytestr()
    path := req.buffer[req.path.start..req.path.start + req.path.len].bytestr()
    version := req.buffer[req.version.start..req.version.start + req.version.len].bytestr()

    assert method == 'GET'
    assert path == '/'
    assert version == 'HTTP/1.1'
}

fn test_parse_request_line_with_path() {
    // Test GET request with path
    request := 'GET /users/123 HTTP/1.1\r\n'.bytes()
    req := decode_http_request(request) or {
        assert false, 'Failed to parse valid request: ${err}'
        return
    }

    path := req.buffer[req.path.start..req.path.start + req.path.len].bytestr()
    assert path == '/users/123'
}

fn test_parse_request_line_post() {
    // Test POST request
    request := 'POST /api/data HTTP/1.1\r\n'.bytes()
    req := decode_http_request(request) or {
        assert false, 'Failed to parse valid request: ${err}'
        return
    }

    method := req.buffer[req.method.start..req.method.start + req.method.len].bytestr()
    path := req.buffer[req.path.start..req.path.start + req.path.len].bytestr()

    assert method == 'POST'
    assert path == '/api/data'
}

fn test_parse_request_line_invalid() {
    // Test invalid request (missing \r\n)
    request := 'GET / HTTP/1.1'.bytes()
    decode_http_request(request) or {
        assert err.msg() == 'Invalid HTTP request line: Missing CR'
        return
    }
    assert false, 'Should have failed to parse invalid request'
}

fn test_decode_http_request() {
    request := 'GET /test HTTP/1.1\r\n'.bytes()
    req := decode_http_request(request) or {
        assert false, 'Failed to decode request: ${err}'
        return
    }

    method := req.buffer[req.method.start..req.method.start + req.method.len].bytestr()
    assert method == 'GET'
}

fn test_new_server() {
    handler := fn (req HttpRequest) !HttpResponse {
        return HttpResponse{
            content: 'HTTP/1.1 200 OK\r\n\r\nHello'.bytes()
        }
    }

    server := new_server(ServerConfig{
        port:    8080
        handler: handler
    }) or {
        assert false, 'Failed to create server: ${err}'
        return
    }

    assert server.port == 8080
}

fn test_server_ipv4_ipv6_binding() {
    // Test IPv4 binding
    handler := fn (req HttpRequest) !HttpResponse {
        return HttpResponse{
            content: 'HTTP/1.1 200 OK\r\n\r\nIPv4 test'.bytes()
        }
    }

    server_ipv4 := new_server(ServerConfig{
        family:  .ip
        port:    8081
        handler: handler
    }) or {
        assert false, 'Failed to create IPv4 server: ${err}'
        return
    }

    // Test IPv6 binding
    server_ipv6 := new_server(ServerConfig{
        family:  .ip6
        port:    8082
        handler: handler
    }) or {
        assert false, 'Failed to create IPv6 server: ${err}'
        return
    }

    // Verify both servers were created successfully
    // Note: family field is not exported, so we can't directly test it
    assert server_ipv4.port == 8081
    assert server_ipv6.port == 8082
}

fn test_response_takeover_mode_reusable_keeps_connection() {
    $if linux || bsd {
        mut server := new_server(ServerConfig{
            family:                  .ip
            port:                    reusable_takeover_port
            timeout_in_seconds:      2
            max_request_buffer_size: 8192
            handler:                 reusable_takeover_handler
        }) or {
            assert false, 'Failed to create server: ${err}'
            return
        }
        handle := server.handle()
        spawn server.run()
        handle.wait_till_running(max_retries: 1000, retry_period_ms: 10) or {
            assert false, 'server did not start: ${err}'
            return
        }
        defer {
            handle.shutdown(timeout: 5 * time.second) or {}
        }

        mut conn := net.dial_tcp(reusable_takeover_addr)!
        conn.set_read_timeout(2 * time.second)
        conn.set_write_timeout(2 * time.second)
        defer {
            conn.close() or {}
        }

        conn.write_string('GET /reus')!
        time.sleep(50 * time.millisecond)
        conn.write_string('able HTTP/1.1\r\nHost: ${reusable_takeover_addr}\r\n\r\n')!
        reusable_response := read_until_contains(mut conn, '\r\n0\r\n\r\n')!
        assert reusable_response.contains('manual') == true, reusable_response
        assert reusable_response.contains('\r\n0\r\n\r\n') == true, reusable_response

        conn.write_string('GET /normal HTTP/1.1\r\nHost: ${reusable_takeover_addr}\r\n\r\n')!
        normal_response := read_until_contains(mut conn, 'normal')!
        assert normal_response.contains('normal') == true, normal_response
        assert normal_response.contains('Connection: close') == false, normal_response
    } $else {
        return
    }
}

fn reusable_takeover_handler(req HttpRequest) !HttpResponse {
    path := req.buffer[req.path.start..req.path.start + req.path.len].bytestr()
    if path == '/reusable' {
        body := 'manual'
        send_raw_response(req.client_conn_fd,
            'HTTP/1.1 200 OK\r\nTransfer-Encoding: chunked\r\n\r\n${body.len:x}\r\n${body}\r\n0\r\n\r\n')
        return HttpResponse{
            takeover_mode: .reusable
        }
    }
    return HttpResponse{
        content: 'HTTP/1.1 200 OK\r\nContent-Length: 6\r\n\r\nnormal'.bytes()
    }
}

fn send_raw_response(fd int, response string) {
    $if linux {
        C.send(fd, response.str, response.len, C.MSG_NOSIGNAL)
    } $else $if bsd {
        C.send(fd, response.str, response.len, send_flags)
    } $else {
        C.send(fd, response.str, response.len, 0)
    }
}

fn read_until_contains(mut conn net.TcpConn, marker string) !string {
    mut raw := ''
    mut buf := []u8{len: 1024}
    for _ in 0 .. 16 {
        n := conn.read(mut buf)!
        if n <= 0 {
            break
        }
        raw += buf[..n].bytestr()
        if raw.contains(marker) {
            break
        }
    }
    return raw
}