// vtest build: !windows && !tinyc // fasthttp.Server.run is not implemented on windows; the test hangs intermittently when built with tcc on linux CI
import net
import net.http
import time
import veb

const graceful_shutdown_host = '127.0.0.1'
const graceful_shutdown_wait_timeout = 10 * time.second

struct GracefulShutdownContext {
    veb.Context
}

struct GracefulShutdownApp {
mut:
    server       &veb.Server = unsafe { nil }
    slow_started chan bool   = chan bool{cap: 1}
}

pub fn (mut app GracefulShutdownApp) init_server(server &veb.Server) {
    app.server = server
}

pub fn (mut app GracefulShutdownApp) index(mut ctx GracefulShutdownContext) veb.Result {
    return ctx.text('ready')
}

@['/slow']
pub fn (mut app GracefulShutdownApp) slow(mut ctx GracefulShutdownContext) veb.Result {
    app.slow_started <- true
    time.sleep(300 * time.millisecond)
    return ctx.text('slow done')
}

fn run_graceful_shutdown_app(mut app GracefulShutdownApp, port int) {
    veb.run_at[GracefulShutdownApp, GracefulShutdownContext](mut app,
        host:                 graceful_shutdown_host
        port:                 port
        family:               .ip
        show_startup_message: false
    ) or { panic(err) }
}

fn send_slow_request(port int, responses chan http.Response) {
    response := http.get('http://${graceful_shutdown_host}:${port}/slow') or { panic(err) }
    responses <- response
}

fn shutdown_graceful_server(server &veb.Server, done chan string) {
    server.shutdown(timeout: 5 * time.second) or {
        done <- err.msg()
        return
    }
    done <- ''
}

fn wait_for_slow_request(started chan bool) ! {
    select {
        _ := <-started {
            return
        }
        graceful_shutdown_wait_timeout {
            return error('slow request did not start')
        }
    }
}

fn wait_for_slow_response(responses chan http.Response) !http.Response {
    select {
        response := <-responses {
            return response
        }
        graceful_shutdown_wait_timeout {
            return error('slow request did not finish')
        }
    }
    return error('slow request did not finish')
}

fn wait_for_shutdown(done chan string) ! {
    select {
        shutdown_error := <-done {
            if shutdown_error != '' {
                return error(shutdown_error)
            }
            return
        }
        graceful_shutdown_wait_timeout {
            return error('server shutdown did not finish')
        }
    }
}

fn wait_for_server(port int) ! {
    url := 'http://${graceful_shutdown_host}:${port}/'
    for _ in 0 .. 100 {
        response := http.get(url) or {
            time.sleep(20 * time.millisecond)
            continue
        }
        if response.status() == .ok && response.body == 'ready' {
            return
        }
        time.sleep(20 * time.millisecond)
    }
    return error('server did not start listening in time')
}

fn test_veb_graceful_shutdown_waits_for_in_flight_requests() {
    mut listener := net.listen_tcp(.ip, '${graceful_shutdown_host}:0') or { panic(err) }
    port := listener.addr()!.port()!
    listener.close() or {}

    mut app := &GracefulShutdownApp{}
    server_thread := spawn run_graceful_shutdown_app(mut app, int(port))

    wait_for_server(int(port)) or {
        assert false, err.msg()
        return
    }

    slow_responses := chan http.Response{cap: 1}
    spawn send_slow_request(int(port), slow_responses)
    wait_for_slow_request(app.slow_started) or {
        assert false, err.msg()
        return
    }

    mut server := app.server
    if server == unsafe { nil } {
        assert false, 'veb server was not initialized'
        return
    }
    shutdown_done := chan string{cap: 1}
    spawn shutdown_graceful_server(server, shutdown_done)

    slow_response := wait_for_slow_response(slow_responses) or {
        assert false, err.msg()
        return
    }
    assert slow_response.status() == .ok
    assert slow_response.body == 'slow done'

    wait_for_shutdown(shutdown_done) or {
        assert false, err.msg()
        return
    }
    server_thread.wait()

    http.get('http://${graceful_shutdown_host}:${port}/') or {
        assert true
        return
    }
    assert false, 'server still accepts new requests after shutdown'
}