module veb

import os

pub interface StaticApp {
mut:
	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 provides methods to handle static files in your veb App
pub struct StaticHandler {
pub mut:
	static_files      map[string]string
	static_mime_types map[string]string
	static_hosts      map[string]string
	static_prefixes   []string
	// enable_static_gzip enables gzip compression for static files.
	// Use this for gzip-only compression. For automatic zstd/gzip selection, use enable_static_compression.
	// Default: false
	enable_static_gzip bool
	// enable_static_zstd enables zstd compression for static files.
	// Use this for zstd-only compression. For automatic zstd/gzip selection, use enable_static_compression.
	// Default: false
	enable_static_zstd bool
	// enable_static_compression enables automatic compression (zstd/gzip) for static files.
	// When enabled, Veb will choose zstd over gzip when client supports both (better compression ratio).
	// For gzip-only or zstd-only compression, use enable_static_gzip or enable_static_zstd instead.
	// Default: false
	enable_static_compression bool
	// static_compression_max_size sets the maximum file size in bytes for auto-compression.
	// Files larger than this threshold will not be auto-compressed.
	// Manual `.zst`/`.gz` files are still served for allowed MIME types.
	// Default: 1MB (1024*1024 bytes). Set to 0 to disable auto-compression completely.
	// Auto-generated cache files are stored in os.cache_dir()/veb/static_compression/.
	// If that cache directory is not writable, compressed content is served from memory as fallback.
	static_compression_max_size int = 1048576
	// static_compression_mime_types limits static compression to the listed MIME types.
	// Manual `.zst`/`.gz` files and auto-generated compressed cache files are only used for matching types.
	// Leave empty to preserve the default behavior and allow compression for all static MIME types.
	static_compression_mime_types []string
	// enable_markdown_negotiation allows the client sends Accept: text/markdown, then the server will serve .md files, if any.
	// Default: false (for backward compatibility)
	enable_markdown_negotiation bool
}

// scan_static_directory recursively scans `directory_path` and returns an error if
// no valid MIME type can be found
fn (mut sh StaticHandler) scan_static_directory(directory_path string, mount_path string, host string) ! {
	files := os.ls(directory_path) or { panic(err) }
	if files.len > 0 {
		for file in files {
			full_path := os.join_path(directory_path, file)
			if os.is_dir(full_path) {
				sh.scan_static_directory(full_path, mount_path.trim_right('/') + '/' + file, host)!
			} else if file.contains('.') && !file.starts_with('.') && !file.ends_with('.') {
				sh.host_serve_static(host, mount_path.trim_right('/') + '/' + file, full_path)!
			}
		}
	}
}

// handle_static is used to mark a folder (relative to the current working folder)
// as one that contains only static resources (css files, images etc).
// If `root` is set the mount path for the dir will be in '/'
// Usage:
// ```v
// os.chdir( os.executable() )?
// app.handle_static('assets', true)
// ```
pub fn (mut sh StaticHandler) handle_static(directory_path string, root bool) !bool {
	return sh.host_handle_static('', directory_path, root)!
}

// host_handle_static is used to mark a folder (relative to the current working folder)
// as one that contains only static resources (css files, images etc).
// If `root` is set the mount path for the dir will be in '/'
// Usage:
// ```v
// os.chdir( os.executable() )?
// app.host_handle_static('localhost', 'assets', true)
// ```
pub fn (mut sh StaticHandler) host_handle_static(host string, directory_path string, root bool) !bool {
	if !os.exists(directory_path) {
		return error('directory `${directory_path}` does not exist. The directory should be relative to the current working directory: ${os.getwd()}')
	}
	dir_path := directory_path.trim_space().trim_right('/')
	mut mount_path := ''
	if dir_path != '.' && os.is_dir(dir_path) && !root {
		// Mount point hygiene, "./assets" => "/assets".
		mount_path = '/' + dir_path.trim_left('.').trim('/')
	}
	sh.scan_static_directory(dir_path, mount_path, host)!
	return true
}

// mount_static_folder_at - makes all static files in `directory_path` and inside it, available at http://server/mount_path
// For example: suppose you have called .mount_static_folder_at('/var/share/myassets', '/assets'),
// and you have a file /var/share/myassets/main.css .
// => That file will be available at URL: http://server/assets/main.css .
pub fn (mut sh StaticHandler) mount_static_folder_at(directory_path string, mount_path string) !bool {
	return sh.host_mount_static_folder_at('', directory_path, mount_path)!
}

// host_mount_static_folder_at - makes all static files in `directory_path` and inside it, available at http://host/mount_path
// For example: suppose you have called .host_mount_static_folder_at('localhost', '/var/share/myassets', '/assets'),
// and you have a file /var/share/myassets/main.css .
// => That file will be available at URL: http://localhost/assets/main.css .
pub fn (mut sh StaticHandler) host_mount_static_folder_at(host string, directory_path string, mount_path string) !bool {
	if mount_path == '' || mount_path[0] != `/` {
		return error('invalid mount path! The path should start with `/`')
	} else if !os.exists(directory_path) {
		return error('directory `${directory_path}` does not exist. The directory should be relative to the current working directory: ${os.getwd()}')
	}

	dir_path := directory_path.trim_right('/')

	trim_mount_path := mount_path.trim_left('/').trim_right('/')
	sh.scan_static_directory(dir_path, '/${trim_mount_path}', host)!
	return true
}

// Serves a file static
// `url` is the access path on the site, `file_path` is the real path to the file, `mime_type` is the file type
pub fn (mut sh StaticHandler) serve_static(url string, file_path string) ! {
	sh.host_serve_static('', url, file_path)!
}

// Serves a file static
// `url` is the access path on the site, `file_path` is the real path to the file
// `host` is the host to serve the file from
pub fn (mut sh StaticHandler) host_serve_static(host string, url string, file_path string) ! {
	ext := os.file_ext(file_path).to_lower()

	// Rudimentary guard against adding files not in mime_types.
	if ext !in sh.static_mime_types && ext !in mime_types {
		return error('unknown MIME type for file extension "${ext}". You can register your MIME type in `app.static_mime_types`')
	}
	sh.static_files[url] = file_path
	sh.static_hosts[url] = host
	sh.register_static_prefix(url)
}

fn static_prefix_for_url(url string) string {
	if url.len == 0 || url[0] != `/` {
		return url
	}
	mut slash_count := 0
	for i in 0 .. url.len {
		if url[i] == `/` {
			slash_count++
			if slash_count == 2 {
				return url[..i + 1]
			}
		}
	}
	return url
}

fn (mut sh StaticHandler) register_static_prefix(url string) {
	prefix := static_prefix_for_url(url)
	if prefix !in sh.static_prefixes {
		sh.static_prefixes << prefix
	}
}

fn app_static_handler[A](app &A) StaticHandler {
	$if A is $struct {
		$for field in A.fields {
			$if field.is_embed {
				$if field.name == 'StaticHandler' {
					return app.$(field.name)
				} $else $if field.typ is $struct {
					return app_static_handler(app.$(field.name))
				}
			}
		}
	}
	return StaticHandler{
		static_files:      map[string]string{}
		static_mime_types: map[string]string{}
		static_hosts:      map[string]string{}
		static_prefixes:   []string{}
	}
}