// vtest build: !windows // fasthttp.Server.run is not implemented on windows yet
import net
import net.http
import time
import veb

const graceful_shutdown_host = '127.0.0.1'

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')
}

pub fn (mut app GracefulShutdownApp) shutdown(mut ctx GracefulShutdownContext) veb.Result {
	spawn app.shutdown_now()
	return ctx.text('shutting down')
}

fn (app &GracefulShutdownApp) shutdown_now() {
	mut server := app.server
	if server == unsafe { nil } {
		panic('veb server was not initialized')
	}
	server.shutdown() or { panic(err) }
}

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 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)
	_ := <-app.slow_started or {
		assert false, 'slow request did not start'
		return
	}

	shutdown_response := http.get('http://${graceful_shutdown_host}:${port}/shutdown') or {
		assert false, err.msg()
		return
	}
	assert shutdown_response.status() == .ok
	assert shutdown_response.body == 'shutting down'

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

	server_thread.wait()

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