module veb

import net.http
import net.urllib
import os

struct RegressionContext {
	Context
}

struct AppStaticRegressionApp {
	Controller
	StaticHandler
}

struct AppStaticRootController {}

fn (app &AppStaticRootController) index(mut ctx RegressionContext) Result {
	return ctx.text('from app static root controller')
}

struct ControllerStaticRootBase {
	StaticHandler
}

struct ControllerStaticRootController {
	ControllerStaticRootBase
}

fn (app &ControllerStaticRootController) index(mut ctx RegressionContext) Result {
	return ctx.text('from controller static root controller')
}

fn test_app_static_is_served_before_root_controller() {
	root_file := regression_testdata_path('root.txt')
	sub_dir := regression_testdata_path('sub_folder')
	sub_file := os.join_path(sub_dir, 'sub.txt')

	mut root_controller := AppStaticRootController{}
	mut app := AppStaticRegressionApp{}
	app.serve_static('/root.txt', root_file) or { panic(err) }
	app.handle_static(sub_dir, true) or { panic(err) }
	app.register_controller[AppStaticRootController, RegressionContext]('/', mut root_controller) or {
		panic(err)
	}

	completed_root := regression_handle_app_request(mut app, regression_request('/root.txt'))
	assert completed_root.return_type == .file
	assert completed_root.return_file == root_file

	completed_sub := regression_handle_app_request(mut app, regression_request('/sub.txt'))
	assert completed_sub.return_type == .file
	assert completed_sub.return_file == sub_file
}

fn test_controller_static_keeps_root_relative_paths() {
	root_file := regression_testdata_path('root.txt')
	sub_dir := regression_testdata_path('sub_folder')
	sub_file := os.join_path(sub_dir, 'sub.txt')

	mut controller_app := ControllerStaticRootController{}
	controller_app.serve_static('/root.txt', root_file) or { panic(err) }
	controller_app.handle_static(sub_dir, true) or { panic(err) }

	ctrl_path := controller[ControllerStaticRootController, RegressionContext]('/', mut
		controller_app) or { panic(err) }

	completed_root := regression_handle_controller_request(ctrl_path, '/root.txt')
	assert completed_root.return_type == .file
	assert completed_root.return_file == root_file

	completed_sub := regression_handle_controller_request(ctrl_path, '/sub.txt')
	assert completed_sub.return_type == .file
	assert completed_sub.return_file == sub_file
}

fn regression_request(url string) http.Request {
	return http.Request{
		method: .get
		url:    url
		header: http.new_custom_header_from_map({
			'Host': '127.0.0.1'
		}) or { panic(err) }
	}
}

fn regression_testdata_path(rel string) string {
	return os.join_path(os.dir(@FILE), 'tests', 'testdata', rel)
}

fn regression_handle_controller_request(ctrl_path &ControllerPath, path string) &Context {
	req := regression_request(path)
	mut url := urllib.parse_request_uri(path) or { panic(err) }
	ctx := &Context{
		req: req
	}
	return ctrl_path.handler(ctx, mut url, '')
}

fn regression_handle_app_request(mut app AppStaticRegressionApp, req http.Request) &Context {
	routes := generate_routes[AppStaticRegressionApp, RegressionContext](app) or { panic(err) }
	controllers_sorted := check_duplicate_routes_in_controllers[AppStaticRegressionApp](app, routes) or {
		panic(err)
	}

	params := RequestParams{
		global_app:                unsafe { voidptr(&app) }
		controllers_sorted:        controllers_sorted
		routes:                    &routes
		benchmark_page_generation: false
	}
	return handle_request_and_route[AppStaticRegressionApp, RegressionContext](mut app, req, 0,
		params)
}