// Copyright (c) 2019-2024 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module veb

import io
import net
import net.http
import net.mbedtls
import net.urllib
import os
import strconv
import strings
import time

// A type which doesn't get filtered inside templates
pub type RawHtml = string

// A dummy structure that returns from routes to indicate that you actually sent something to a user
@[noinit]
pub struct Result {}

// no_result does nothing, but returns `veb.Result`. Only use it when you are sure
// a response will be send over the connection, or in combination with `Context.takeover_conn`
pub fn no_result() Result {
	return Result{}
}

struct Route {
	methods []http.Method
	path    string
	words   []string
	host    string
mut:
	middlewares       []RouteMiddleware
	after_middlewares []RouteMiddleware
}

fn route_path_words(path string) []string {
	if path.len == 0 || path == '/' {
		return []string{}
	}
	return path.split('/').filter(it != '')
}

// Generate route structs for an app
fn generate_routes[A, X](app &A) !map[string]Route {
	// Parsing methods attributes
	mut routes := map[string]Route{}
	$for method in A.methods {
		$if method.return_type is Result {
			http_methods, route_path, host := parse_attrs(method.name, method.attrs) or {
				return error('error parsing method attributes: ${err}')
			}

			mut route := Route{
				methods: http_methods
				path:    route_path
				words:   route_path_words(route_path)
				host:    host
			}

			$if A is MiddlewareApp {
				route.middlewares = app_route_handlers(app, route_path)
				route.after_middlewares = app_route_handlers_after(app, route_path)
			}

			routes[method.name] = route
		} $else {
			// If we have route attributes, but the wrong return type, return an error
			if has_route_attributes(method.attrs) {
				return error('method `${method.name}` at `${method.location}` has route attributes but invalid return type. Handler methods must return `veb.Result`, not `!veb.Result` or other types')
			}
		}
	}
	return routes
}

// run - start a new veb server, listening to all available addresses, at the specified `port`
pub fn run[A, X](mut global_app A, port int) {
	run_at[A, X](mut global_app, host: '', port: port, family: .ip6) or { panic(err.msg()) }
}

@[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
}

struct SslRequestParams {
	global_app                voidptr
	controllers_sorted        []&ControllerPath
	routes                    &map[string]Route
	benchmark_page_generation bool
	max_request_buffer_size   int
}

fn ssl_enabled(params RunParams) bool {
	return params.ssl_config.cert != '' || params.ssl_config.cert_key != ''
}

fn server_protocol(params RunParams) string {
	if ssl_enabled(params) {
		return 'https'
	}
	return 'http'
}

fn startup_host(params RunParams) string {
	if params.host == '' {
		return 'localhost'
	}
	return params.host
}

fn listen_addr(params RunParams) string {
	if params.host == '' {
		return ':${params.port}'
	}
	return '${params.host}:${params.port}'
}

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 read_request_from_buffered_reader(mut reader io.BufferedReader) !http.Request {
	mut req := http.parse_request_head(mut reader)!
	if transfer_encoding_is_chunked(req.header) {
		req.data = read_chunked_request_body(mut reader)!
		return req
	}
	content_length := req.header.get(.content_length) or { '0' }
	content_length_i := content_length.int()
	if content_length_i <= 0 {
		return req
	}
	mut body := []u8{len: content_length_i}
	read_exact_bytes(mut reader, mut body)!
	req.data = body.bytestr()
	return req
}

fn transfer_encoding_is_chunked(header http.Header) bool {
	transfer_encoding := header.get(.transfer_encoding) or { return false }
	for word in transfer_encoding.to_lower().split(',') {
		if word.trim_space() == 'chunked' {
			return true
		}
	}
	return false
}

fn read_chunked_request_body(mut reader io.BufferedReader) !string {
	mut sb := strings.new_builder(1024)
	for {
		mut chunk_size_line := reader.read_line()!
		if semicolon_idx := chunk_size_line.index(';') {
			chunk_size_line = chunk_size_line[..semicolon_idx]
		}
		chunk_size_line = chunk_size_line.trim_space()
		if chunk_size_line.len == 0 {
			return error('invalid chunk size line')
		}
		chunk_size_u64 := strconv.parse_uint(chunk_size_line, 16, 64) or {
			return error('invalid chunk size line')
		}
		if chunk_size_u64 > u64(max_int) {
			return error('chunk size too large')
		}
		chunk_size := int(chunk_size_u64)
		if chunk_size == 0 {
			for {
				trailer := reader.read_line()!
				if trailer == '' {
					return sb.str()
				}
			}
		}
		mut chunk := []u8{len: chunk_size}
		read_exact_bytes(mut reader, mut chunk)!
		sb.write(chunk)!
		mut delimiter := []u8{len: 2}
		read_exact_bytes(mut reader, mut delimiter)!
		if delimiter[0] != `\r` || delimiter[1] != `\n` {
			return error('invalid chunk delimiter')
		}
	}
	return error('invalid chunked body')
}

fn read_exact_bytes(mut reader io.BufferedReader, mut buf []u8) ! {
	mut offset := 0
	for offset < buf.len {
		offset += reader.read(mut buf[offset..])!
	}
}

fn handle_ssl_request[A, X](req http.Request, params &SslRequestParams) ?&Context {
	mut global_app := unsafe { &A(params.global_app) }
	page_gen_start := time.ticks()
	mut url := urllib.parse(req.url) or {
		eprintln('[veb] error parsing path "${req.url}": ${err}')
		return none
	}
	query := parse_query_from_url(url)
	form, files := parse_form_from_request(req) or {
		eprintln('[veb] error parsing form: ${err.msg()}')
		return none
	}
	host_with_port := req.header.get(.host) or { '' }
	host := request_host_name(host_with_port)
	mut ctx := &Context{
		req:            req
		page_gen_start: page_gen_start
		query:          query
		form:           form
		files:          files
	}
	ctx.client_wants_to_close = request_has_connection_close(req)
	mut user_context := X{
		Context: ctx
	}
	$if A is StaticApp {
		ctx.custom_mime_types_ref = unsafe { &global_app.static_mime_types }
		if serve_if_static[X](static_handler_config(global_app.static_files,
			global_app.static_mime_types, global_app.static_hosts, global_app.static_prefixes,
			global_app.enable_static_gzip, global_app.enable_static_zstd,
			global_app.enable_static_compression, global_app.static_compression_max_size,
			global_app.static_compression_mime_types, global_app.enable_markdown_negotiation), mut
			user_context, url, host)
		{
			// Preserve the handled context on the heap before the stack-local user context goes away.
			unsafe {
				*ctx = user_context.Context
			}
			return ctx
		}
	}
	$if A is ControllerInterface {
		if completed_context := handle_controllers[X](params.controllers_sorted, ctx, mut url, host) {
			return completed_context
		}
	}
	handle_route[A, X](mut global_app, mut user_context, url, host, params.routes)
	// Preserve the handled context on the heap before the stack-local user context goes away.
	unsafe {
		*ctx = user_context.Context
	}
	return ctx
}

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())!
}

fn request_has_connection_close(req http.Request) bool {
	conn := req.header.get(.connection) or { return false }
	return ascii_eq_ignore_case(conn, 'close')
}

fn request_host_name(host_with_port string) string {
	if host_with_port.len == 0 {
		return ''
	}
	if host_with_port[0] == `[` {
		end := host_with_port.index_u8(`]`)
		if end > 0 {
			return host_with_port[1..end]
		}
		return host_with_port
	}
	colon := host_with_port.last_index_u8(`:`)
	if colon == -1 {
		return host_with_port
	}
	for i in 0 .. colon {
		if host_with_port[i] == `:` {
			return host_with_port
		}
	}
	return host_with_port[..colon]
}

fn ascii_eq_ignore_case(a string, b string) bool {
	if a.len != b.len {
		return false
	}
	for i in 0 .. a.len {
		mut ca := a[i]
		if ca >= `A` && ca <= `Z` {
			ca += 32
		}
		mut cb := b[i]
		if cb >= `A` && cb <= `Z` {
			cb += 32
		}
		if ca != cb {
			return false
		}
	}
	return true
}

fn should_close_connection(req http.Request, resp http.Response, client_wants_to_close bool) bool {
	if client_wants_to_close {
		return true
	}
	if resp_conn := resp.header.get(.connection) {
		if ascii_eq_ignore_case(resp_conn, 'close') {
			return true
		}
		if ascii_eq_ignore_case(resp_conn, 'keep-alive') {
			return false
		}
	}
	if req_conn := req.header.get(.connection) {
		if ascii_eq_ignore_case(req_conn, 'close') {
			return true
		}
		if ascii_eq_ignore_case(req_conn, 'keep-alive') {
			return false
		}
	}
	return req.version != .v1_1
}

interface BeforeAcceptApp {
mut:
	before_accept_loop()
}

interface HasBeforeRequestOnContext {
mut:
	before_request()
}

fn handle_route[A, X](mut app A, mut user_context X, url urllib.URL, host string, routes &map[string]Route) {
	mut route := Route{}
	mut middleware_has_sent_response := false
	mut not_found := false
	mut variadic_route := Route{}
	mut variadic_route_words := []string{}
	mut variadic_method_name := ''
	mut variadic_method_args := []string{}

	defer {
		// execute middleware functions after veb is done and before the response is send
		mut was_done := true
		$if A is MiddlewareApp {
			if !not_found && !middleware_has_sent_response {
				// if the middleware doesn't send an alternate response, but only changes the
				// response object we only have to check if the `done` was previously set to true
				was_done = user_context.Context.done
				// reset `done` so the middleware functions can return a different response
				// 1 time only, since the `done` guard is still present in
				// `Context.send_response_to_client`
				user_context.Context.done = false

				// no need to check the result of `validate_middleware`, since a response has to be sent
				// anyhow. This function makes sure no further middleware is executed.
				validate_middleware[X](mut user_context, app_global_handlers_after(app))
				// skip route-specific after-middleware if global already sent a response
				if !user_context.Context.done {
					validate_middleware[X](mut user_context, get_handlers_for_method(route.after_middlewares,
						user_context.Context.req.method))
				}
			}
		}
		// send only the headers, because if the response body is too big, TcpConn code will
		// actually block, because it has to wait for the socket to become ready to write. veb
		// will handle this case.
		if !was_done && !user_context.Context.done && user_context.Context.takeover_mode == .none {
			eprintln('[veb] handler for route "${url.path}" does not send any data!')
			// send response anyway so the connection won't block
			// fast_send_resp_header(mut user_context.conn, user_context.res) or {}
		} else if user_context.Context.takeover_mode == .none {
			// fast_send_resp_header(mut user_context.conn, user_context.res) or {}
		}
		// Context.takeover_mode is set, so the user must send a response.
	}

	is_root_path := url.path.len == 0 || url.path == '/'

	$if veb_livereload ? {
		if url.path.starts_with('/veb_livereload/') {
			if url.path.ends_with('current') {
				user_context.handle_veb_livereload_current()
				return
			}
			if url.path.ends_with('script.js') {
				user_context.handle_veb_livereload_script()
				return
			}
		}
	}

	// first execute before_request
	$if X is HasBeforeRequestOnContext {
		user_context.before_request()
	}
	// user_context.before_request()
	if user_context.Context.done {
		return
	}
	$if trace_prealloc ? {
		unsafe { prealloc_scope_checkpoint(c'veb before_request done') }
	}

	// then execute global middleware functions
	$if A is MiddlewareApp {
		if validate_middleware[X](mut user_context, app_global_handlers(app)) == false {
			middleware_has_sent_response = true
			return
		}
	}

	$if A is StaticApp {
		should_check_static := !is_root_path || app.enable_markdown_negotiation
			|| app.static_files['/'] != '' || app.static_files['/index.html'] != ''
			|| app.static_files['/index.htm'] != ''
		if should_check_static {
			if serve_if_static[X](static_handler_config(app.static_files, app.static_mime_types,
				app.static_hosts, app.static_prefixes, app.enable_static_gzip,
				app.enable_static_zstd, app.enable_static_compression,
				app.static_compression_max_size, app.static_compression_mime_types,
				app.enable_markdown_negotiation), mut user_context, url, host)
			{
				// successfully served a static file
				return
			}
		}
	}
	$if trace_prealloc ? {
		unsafe { prealloc_scope_checkpoint(c'veb route static checked') }
	}
	$if trace_prealloc ? {
		unsafe { prealloc_scope_checkpoint(c'veb before route match') }
	}

	if is_root_path {
		$for method in A.methods {
			$if method.name == 'index' && method.return_type is Result {
				route = (*routes)[method.name] or {
					eprintln('[veb] parsed attributes for the `${method.name}` are not found, skipping...')
					Route{}
				}
				if user_context.Context.req.method in route.methods
					&& (route.host == '' || route.host == host)
					&& (route.path == '/' || route.path == '/index') {
					$if A is MiddlewareApp {
						if validate_middleware[X](mut user_context, get_handlers_for_method(route.middlewares,
							user_context.Context.req.method)) == false {
							middleware_has_sent_response = true
							return
						}
					}
					can_have_data_args := user_context.Context.req.method == .post
						|| user_context.Context.req.method == .get
					if method.args.len > 1 && can_have_data_args {
						mut args := []string{cap: method.args.len + 1}
						data := if user_context.Context.req.method == .get {
							user_context.Context.query
						} else {
							user_context.Context.form
						}
						for param in method.args[1..] {
							args << data[param.name]
						}
						$if trace_prealloc ? {
							unsafe { prealloc_scope_checkpoint(c'veb before route handler') }
						}
						app.$method(mut user_context, ...args)
						$if trace_prealloc ? {
							unsafe { prealloc_scope_checkpoint(c'veb after route handler') }
						}
					} else {
						$if trace_prealloc ? {
							unsafe { prealloc_scope_checkpoint(c'veb before route handler') }
						}
						app.$method(mut user_context)
						$if trace_prealloc ? {
							unsafe { prealloc_scope_checkpoint(c'veb after route handler') }
						}
					}
					return
				}
			}
		}
	}

	url_words := route_path_words(url.path)
	$if trace_prealloc ? {
		unsafe { prealloc_scope_checkpoint(c'veb route words parsed') }
	}

	// Route matching and match route specific middleware as last step
	$for method in A.methods {
		$if method.return_type is Result {
			route = (*routes)[method.name] or {
				eprintln('[veb] parsed attributes for the `${method.name}` are not found, skipping...')
				Route{}
			}

			// Skip if the HTTP request method does not match the attributes
			if user_context.Context.req.method in route.methods {
				// Used for route matching
				route_words := route.words

				// Skip if the host does not match or is empty
				if route.host == '' || route.host == host {
					can_have_data_args := user_context.Context.req.method == .post
						|| user_context.Context.req.method == .get
					// Route immediate matches first
					// For example URL `/register` matches route `/:user`, but `fn register()`
					// should be called first.
					if !route.path.contains('/:') && url_words == route_words {
						// We found a match
						$if A is MiddlewareApp {
							if validate_middleware[X](mut user_context, get_handlers_for_method(route.middlewares,
								user_context.Context.req.method)) == false {
								middleware_has_sent_response = true
								return
							}
						}
						if method.args.len > 1 && can_have_data_args {
							// Populate method args with form or query values
							mut args := []string{cap: method.args.len + 1}
							data := if user_context.Context.req.method == .get {
								user_context.Context.query
							} else {
								user_context.Context.form
							}
							for param in method.args[1..] {
								args << data[param.name]
							}
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb before route handler') }
							}
							app.$method(mut user_context, ...args)
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb after route handler') }
							}
						} else {
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb before route handler') }
							}
							app.$method(mut user_context)
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb after route handler') }
							}
						}
						return
					}

					if url_words.len == 0 && route_words.len == 1 && route_words[0] == 'index'
						&& method.name == 'index' {
						$if A is MiddlewareApp {
							if validate_middleware[X](mut user_context, get_handlers_for_method(route.middlewares,
								user_context.Context.req.method)) == false {
								middleware_has_sent_response = true
								return
							}
						}

						if method.args.len > 1 && can_have_data_args {
							// Populate method args with form or query values
							mut args := []string{cap: method.args.len + 1}
							data := if user_context.Context.req.method == .get {
								user_context.Context.query
							} else {
								user_context.Context.form
							}
							for param in method.args[1..] {
								args << data[param.name]
							}
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb before route handler') }
							}
							app.$method(mut user_context, ...args)
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb after route handler') }
							}
						} else {
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb before route handler') }
							}
							app.$method(mut user_context)
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb after route handler') }
							}
						}
						return
					}

					if params := route_matches(url_words, route_words) {
						if route_is_variadic(route_words) {
							if should_prefer_variadic_route(route_words, variadic_route_words) {
								variadic_route = route
								variadic_route_words = route_words.clone()
								variadic_method_name = method.name
								variadic_method_args = params.clone()
							}
						} else {
							$if A is MiddlewareApp {
								if validate_middleware[X](mut user_context, get_handlers_for_method(route.middlewares,
									user_context.Context.req.method)) == false {
									middleware_has_sent_response = true
									return
								}
							}
							method_args := params.clone()
							if method_args.len + 1 != method.args.len {
								eprintln('[veb] warning: uneven parameters count (${method.args.len}) in `${method.name}`, compared to the veb route `${method.attrs}` (${method_args.len})')
							}
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb before route handler') }
							}
							app.$method(mut user_context, ...method_args)
							$if trace_prealloc ? {
								unsafe { prealloc_scope_checkpoint(c'veb after route handler') }
							}
							return
						}
					}
				}
			}
		}
	}
	if variadic_method_name != '' {
		route = variadic_route
		$for method in A.methods {
			$if method.return_type is Result {
				if method.name == variadic_method_name {
					$if A is MiddlewareApp {
						if validate_middleware[X](mut user_context, get_handlers_for_method(variadic_route.middlewares,
							user_context.Context.req.method)) == false {
							middleware_has_sent_response = true
							return
						}
					}
					method_args := variadic_method_args.clone()
					if method_args.len + 1 != method.args.len {
						eprintln('[veb] warning: uneven parameters count (${method.args.len}) in `${method.name}`, compared to the veb route `${method.attrs}` (${method_args.len})')
					}
					$if trace_prealloc ? {
						unsafe { prealloc_scope_checkpoint(c'veb before route handler') }
					}
					app.$method(mut user_context, ...method_args)
					$if trace_prealloc ? {
						unsafe { prealloc_scope_checkpoint(c'veb after route handler') }
					}
					return
				}
			}
		}
	}
	// return 404
	user_context.not_found()
	not_found = true
	return
}

fn route_is_variadic(route_words []string) bool {
	return route_words.len > 0 && route_words[route_words.len - 1].ends_with('...')
}

fn should_prefer_variadic_route(candidate []string, current []string) bool {
	if current.len == 0 {
		return true
	}
	if candidate.len != current.len {
		return candidate.len > current.len
	}
	return variadic_route_static_parts(candidate) > variadic_route_static_parts(current)
}

fn variadic_route_static_parts(route_words []string) int {
	mut static_parts := 0
	for route_word in route_words[..route_words.len - 1] {
		if !route_word.starts_with(':') {
			static_parts++
		}
	}
	return static_parts
}

fn route_matches(url_words []string, route_words []string) ?[]string {
	// URL path should be at least as long as the route path
	// except for the catchall route (`/:path...`)
	if route_words.len == 1 && route_words[0].starts_with(':') && route_words[0].ends_with('...') {
		return ['/' + url_words.join('/')]
	}
	if url_words.len < route_words.len {
		return none
	}
	mut params := []string{cap: url_words.len}
	if url_words.len == route_words.len {
		for i in 0 .. url_words.len {
			if route_words[i].starts_with(':') {
				// We found a path parameter
				params << url_words[i]
			} else if route_words[i] != url_words[i] {
				// This url does not match the route
				return none
			}
		}
		return params
	}

	// The last route can end with ... indicating an array
	if route_words.len == 0 || !route_words[route_words.len - 1].ends_with('...') {
		return none
	}

	for i in 0 .. route_words.len - 1 {
		if route_words[i].starts_with(':') {
			// We found a path parameter
			params << url_words[i]
		} else if route_words[i] != url_words[i] {
			// This url does not match the route
			return none
		}
	}
	params << url_words[route_words.len - 1..url_words.len].join('/')
	return params
}

// check if request is for a static file and serves it
// returns true if we served a static file, false otherwise
fn serve_if_static[X](app StaticHandler, mut user_context X, url urllib.URL, host string) bool {
	// TODO: handle url parameters properly - for now, ignore them
	mut asked_path := url.path
	static_handler := app
	if !static_handler.enable_markdown_negotiation && asked_path == '/'
		&& static_handler.static_files['/'] == ''
		&& static_handler.static_files['/index.html'] == ''
		&& static_handler.static_files['/index.htm'] == '' {
		return false
	}
	if !static_handler.enable_markdown_negotiation
		&& !static_handler.may_contain_static_path(asked_path) {
		return false
	}

	// Content negotiation for markdown files (if enabled)
	if static_handler.enable_markdown_negotiation {
		accept_header := user_context.req.header.get(.accept) or { '' }
		if accept_header.contains('text/markdown') {
			// Try markdown variants in order of priority
			markdown_variants := [
				asked_path + '.md',
				asked_path + '.html.md',
				asked_path + '/index.html.md',
			]

			for variant in markdown_variants {
				if static_handler.static_files[variant] != '' {
					asked_path = variant
					break
				}
			}
		}
	}

	base_path := os.base(asked_path)
	if !base_path.contains('.') && !asked_path.ends_with('/') {
		asked_path += '/'
	}

	if asked_path.ends_with('/') {
		// Check for markdown index first if Accept header requests it and feature is enabled
		if static_handler.enable_markdown_negotiation {
			accept_header := user_context.req.header.get(.accept) or { '' }
			if accept_header.contains('text/markdown')
				&& static_handler.static_files[asked_path + 'index.html.md'] != '' {
				asked_path += 'index.html.md'
			} else if static_handler.static_files[asked_path + 'index.html'] != '' {
				asked_path += 'index.html'
			} else if static_handler.static_files[asked_path + 'index.htm'] != '' {
				asked_path += 'index.htm'
			}
		} else if static_handler.static_files[asked_path + 'index.html'] != '' {
			asked_path += 'index.html'
		} else if static_handler.static_files[asked_path + 'index.htm'] != '' {
			asked_path += 'index.htm'
		}
	}
	static_file := static_handler.static_files[asked_path] or { return false }

	// StaticHandler ensures that the mime type exists on either the App or in veb
	ext := os.file_ext(static_file).to_lower()
	mut mime_type := static_handler.static_mime_types[ext] or { mime_types[ext] }

	static_host := static_handler.static_hosts[asked_path] or { '' }
	if static_file == '' || mime_type == '' {
		return false
	}
	if static_host != '' && static_host != host {
		return false
	}

	// Configure static file compression settings
	user_context.set_static_compression_config(static_handler.enable_static_gzip,
		static_handler.enable_static_zstd, static_handler.enable_static_compression, if static_handler.static_compression_max_size >= 0 {
		static_handler.static_compression_max_size
	} else {
		1048576 // Default: 1MB
	}, static_handler.static_compression_mime_types)

	user_context.send_file(mime_type, static_file)
	return true
}

fn (sh StaticHandler) may_contain_static_path(path string) bool {
	if sh.static_prefixes.len == 0 || path == '/' {
		return true
	}
	for prefix in sh.static_prefixes {
		if prefix.ends_with('/') {
			if path.starts_with(prefix) {
				return true
			}
		} else if path == prefix {
			return true
		}
	}
	return false
}

fn static_handler_config(static_files map[string]string, static_mime_types map[string]string, static_hosts map[string]string, static_prefixes []string, enable_static_gzip bool, enable_static_zstd bool, enable_static_compression bool, static_compression_max_size int, static_compression_mime_types []string, enable_markdown_negotiation bool) StaticHandler {
	return StaticHandler{
		static_files:                  static_files
		static_mime_types:             static_mime_types
		static_hosts:                  static_hosts
		static_prefixes:               static_prefixes
		enable_static_gzip:            enable_static_gzip
		enable_static_zstd:            enable_static_zstd
		enable_static_compression:     enable_static_compression
		static_compression_max_size:   static_compression_max_size
		static_compression_mime_types: static_compression_mime_types
		enable_markdown_negotiation:   enable_markdown_negotiation
	}
}

// send a string over `conn`
fn send_string(mut conn net.TcpConn, s string) ! {
	$if trace_send_string_conn ? {
		eprintln('> send_string: conn: ${ptr_str(conn)}')
	}
	$if trace_response ? {
		eprintln('> send_string:\n${s}\n')
	}
	if voidptr(conn) == unsafe { nil } {
		return error('connection was closed before send_string')
	}
	conn.write_string(s)!
}

// Set s to the form error
pub fn (mut ctx Context) error(s string) {
	eprintln('[veb] Context.error: ${s}')
	ctx.form_error = s
}

fn fast_send_resp_header(mut conn net.TcpConn, resp http.Response) ! {
	mut sb := strings.new_builder(resp.body.len + 200)
	sb.write_string('HTTP/')
	sb.write_string(resp.http_version)
	sb.write_string(' ')
	sb.write_decimal(resp.status_code)
	sb.write_string(' ')
	sb.write_string(resp.status_msg)
	sb.write_string('\r\n')

	resp.header.render_into_sb(mut sb,
		version: resp.version()
	)
	sb.write_string('\r\n')
	send_string(mut conn, sb.str())!
}

// Formats resp to a string suitable for HTTP response transmission
// A fast version of `resp.bytestr()` used with
// `send_string(mut ctx.conn, resp.bytestr())`
fn fast_send_resp(mut conn net.TcpConn, resp http.Response) ! {
	fast_send_resp_header(mut conn, resp)!
	send_string(mut conn, resp.body)!
}