module pref

import os

// Preferences represents preferences data used by pref.
pub struct Preferences {
pub mut:
	verbose      bool
	output_file  string
	target_os    string = os.user_os()
	user_defines []string
	backend      string = 'c'
	c99          bool
	vroot        string = detect_vroot()
	selfhost     bool
	building_v   bool // compiling the V compiler itself: no generics, skip monomorphization
}

// new_preferences supports new preferences handling for pref.
pub fn new_preferences() &Preferences {
	return &Preferences{}
}

// detect_vroot resolves detect vroot information for pref.
fn detect_vroot() string {
	baked_root := @VMODROOT
	if baked_root.len > 0 {
		return baked_root
	}
	if os.args.len > 0 && os.args[0].len > 0 {
		vroot := detect_vroot_from(os.args[0])
		if vroot.len > 0 {
			return vroot
		}
	}
	return detect_vroot_from(os.getwd())
}

// detect_vroot_from resolves detect vroot from information for pref.
fn detect_vroot_from(start string) string {
	if start.len == 0 {
		return ''
	}
	mut dir := start
	if !os.is_abs_path(dir) {
		cwd := os.getwd()
		if cwd.len > 0 {
			dir = os.join_path_single(cwd, dir)
		}
	}
	if !os.is_dir(dir) {
		dir = os.dir(dir)
	}
	for _ in 0 .. 8 {
		if os.is_dir(os.join_path_single(os.join_path_single(dir, 'vlib'), 'builtin')) {
			return dir
		}
		parent := os.dir(dir)
		if parent == dir {
			break
		}
		dir = parent
	}
	return ''
}

// get_vlib_module_path returns get vlib module path data for Preferences.
pub fn (p &Preferences) get_vlib_module_path(mod string) string {
	mod_path := mod.replace('.', os.path_separator)
	return os.join_path_single(os.join_path_single(p.vroot, 'vlib'), mod_path)
}

// get_module_path returns get module path data for Preferences.
pub fn (p &Preferences) get_module_path(mod string, importing_file_path string) string {
	mod_path := mod.replace('.', os.path_separator)
	// Absolutize the importer like V1's Builder.find_module_path does
	// (`os.real_path(fpath)`). When the input is given as a relative path (e.g.
	// `v3 -o out .`), the parsed file paths are relative too (`./doka.v`), and a
	// parent-directory walk starting from `.` could never climb above the project
	// dir to find sibling modules.
	abs_importer := os.real_path(importing_file_path)
	importer_dir := os.dir(abs_importer)
	// 1. relative to the importing file's directory
	relative_path := os.join_path_single(importer_dir, mod_path)
	if dir_is_module(relative_path) {
		return relative_path
	}
	// 2. vlib
	vlib_path := os.join_path_single(os.join_path_single(p.vroot, 'vlib'), mod_path)
	if dir_is_module(vlib_path) {
		return vlib_path
	}
	// 3. ~/.vmodules (or $VMODULES)
	vmodules_path := os.join_path_single(vmodules_dir(), mod_path)
	if dir_is_module(vmodules_path) {
		return vmodules_path
	}
	// 4. walk up the parent directories of the importing file, like V1's
	// Builder.find_module_path. This finds sibling projects: e.g. importing
	// `viper` from ~/code/doka/doka.v resolves to ~/code/viper.
	mut current_dir := importer_dir
	for {
		try_path := os.join_path_single(current_dir, mod_path)
		if dir_is_module(try_path) {
			return try_path
		}
		parent_dir := os.dir(current_dir)
		if parent_dir == current_dir {
			break
		}
		current_dir = parent_dir
	}
	return ''
}

// dir_is_module reports whether `dir` is a usable module directory: it must exist
// and contain at least one `.v` source file. V1 applies the same `.v`-files guard
// (`module_path_has_v_files`); without it the parent-directory walk could match an
// unrelated directory that merely shares a module's name (e.g. `~/code/util`),
// shadowing the real module.
fn dir_is_module(dir string) bool {
	if dir.len == 0 || !os.is_dir(dir) {
		return false
	}
	entries := os.ls(dir) or { return false }
	for entry in entries {
		if entry.ends_with('.v') {
			return true
		}
	}
	return false
}

// vmodules_dir returns the user's global modules directory ($VMODULES or ~/.vmodules).
fn vmodules_dir() string {
	env_dir := os.getenv('VMODULES')
	if env_dir.len > 0 {
		return env_dir
	}
	return os.join_path_single(os.home_dir(), '.vmodules')
}

// file_has_incompatible_os_suffix converts file has incompatible os suffix data for pref.
pub fn file_has_incompatible_os_suffix(file string, current_os string) bool {
	os_name := normalized_os(current_os)
	if os_name == 'windows' && file.contains('_nix.') {
		return true
	}
	if os_name != 'windows' && file.contains('_windows.') {
		return true
	}
	if os_name != 'linux' && file.contains('_linux.') {
		return true
	}
	if os_name != 'macos' && (file.contains('_macos.') || file.contains('_darwin.')) {
		return true
	}
	if os_name != 'macos' && os_name != 'freebsd' && os_name != 'openbsd' && os_name != 'netbsd'
		&& os_name != 'dragonfly' && file.contains('_bsd.') {
		return true
	}
	if os_name != 'android' && file.contains('_android') {
		return true
	}
	if os_name != 'ios' && file.contains('_ios.') {
		return true
	}
	if os_name != 'freebsd' && file.contains('_freebsd.') {
		return true
	}
	if os_name != 'openbsd' && file.contains('_openbsd.') {
		return true
	}
	if os_name != 'netbsd' && file.contains('_netbsd.') {
		return true
	}
	if os_name != 'dragonfly' && file.contains('_dragonfly.') {
		return true
	}
	if os_name != 'solaris' && file.contains('_solaris.') {
		return true
	}
	if file.contains('.amd64.') || file.contains('_amd64.') || file.contains('.arm64.')
		|| file.contains('_arm64.') {
		return true
	}
	return false
}

// get_v_files_from_dir returns get v files from dir data for pref.
pub fn get_v_files_from_dir(dir string, user_defines []string, target_os string) []string {
	if dir == '' || !os.is_dir(dir) {
		return []string{}
	}
	all_files := os.ls(dir) or { return []string{} }
	mut sorted_files := all_files.clone()
	sorted_files.sort()
	mut has_os_specific := map[string]bool{}
	for file in sorted_files {
		if !file.ends_with('.v') || file.ends_with('.js.v') || file.contains('_test.') {
			continue
		}
		if file_has_incompatible_os_suffix(file, target_os) {
			continue
		}
		if base := os_specific_base(file, target_os) {
			has_os_specific[base] = true
		}
	}
	mut v_files := []string{}
	for backend_specific in [false, true] {
		for file in sorted_files {
			if file.ends_with('.c.v') != backend_specific {
				continue
			}
			if !file.ends_with('.v') || file.ends_with('.js.v') || file.contains('_test.') {
				continue
			}
			if file_has_incompatible_os_suffix(file, target_os) {
				continue
			}
			if base := default_file_base(file) {
				if has_os_specific[base] {
					continue
				}
			}
			if file.contains('_notd_') {
				feature := extract_define_feature(file, '_notd_')
				if feature.len > 0 && feature in user_defines {
					continue
				}
			} else if file.contains('_d_') {
				feature := extract_define_feature(file, '_d_')
				if feature.len == 0 || feature !in user_defines {
					continue
				}
			}
			v_files << os.join_path_single(dir, file)
		}
	}
	return v_files
}

pub fn is_test_file_for_backend(path string, backend string) bool {
	file := os.file_name(path)
	if file.ends_with('_test.v') {
		return true
	}
	if file.ends_with('_test.c.v') {
		return backend == 'c'
	}
	if file.ends_with('_test.js.v') {
		return backend == 'js'
	}
	if !file.ends_with('.v') {
		return false
	}
	base := file[..file.len - 2]
	if !base.contains('.') {
		return false
	}
	backend_suffix := base.all_after_last('.')
	test_base := base.all_before_last('.')
	if !test_base.ends_with('_test') {
		return false
	}
	return backend_suffix == backend
}

// default_file_base supports default file base handling for pref.
fn default_file_base(file string) ?string {
	for marker in ['_default.c.v', '_default.v'] {
		if file.ends_with(marker) {
			return file[..file.len - marker.len]
		}
	}
	return none
}

// os_specific_base supports os specific base handling for pref.
fn os_specific_base(file string, target_os string) ?string {
	if _ := default_file_base(file) {
		return none
	}
	mut suffixes := []string{}
	os_name := normalized_os(target_os)
	if os_name != 'windows' {
		suffixes << '_nix'
	}
	match os_name {
		'windows' {
			suffixes << '_windows'
		}
		'macos' {
			suffixes << '_macos'
			suffixes << '_darwin'
		}
		'linux' {
			suffixes << '_linux'
		}
		'android' {
			suffixes << '_android'
		}
		'ios' {
			suffixes << '_ios'
		}
		'freebsd' {
			suffixes << '_freebsd'
			suffixes << '_bsd'
		}
		'openbsd' {
			suffixes << '_openbsd'
			suffixes << '_bsd'
		}
		'netbsd' {
			suffixes << '_netbsd'
			suffixes << '_bsd'
		}
		'dragonfly' {
			suffixes << '_dragonfly'
			suffixes << '_bsd'
		}
		'solaris' {
			suffixes << '_solaris'
		}
		else {}
	}

	for suffix in suffixes {
		for ext in ['.c.v', '.v'] {
			marker := suffix + ext
			if file.ends_with(marker) {
				return file[..file.len - marker.len]
			}
		}
	}
	return none
}

// extract_define_feature supports extract define feature handling for pref.
fn extract_define_feature(file string, marker string) string {
	idx := file.index(marker) or { return '' }
	rest := file[idx + marker.len..]
	if rest.ends_with('.c.v') {
		return rest[..rest.len - 4]
	}
	if rest.ends_with('.v') {
		return rest[..rest.len - 2]
	}
	return rest
}

// normalized_os supports normalized os handling for pref.
pub fn normalized_os(target_os string) string {
	return match target_os {
		'darwin' { 'macos' }
		'mac' { 'macos' }
		else { target_os }
	}
}

// normalized_target_os supports normalized target os handling for Preferences.
pub fn (p &Preferences) normalized_target_os() string {
	return normalized_os(p.target_os)
}

// is_cross_target reports whether is cross target applies in pref.
pub fn (p &Preferences) is_cross_target() bool {
	return p.normalized_target_os() != normalized_os(os.user_os())
}

// comptime_flag_value supports comptime flag value handling for pref.
pub fn comptime_flag_value(p &Preferences, name string) bool {
	match name {
		'macos', 'darwin', 'mac' {
			return p.normalized_target_os() == 'macos'
		}
		'linux' {
			return p.normalized_target_os() == 'linux'
		}
		'windows' {
			return p.normalized_target_os() == 'windows'
		}
		'freebsd' {
			return p.normalized_target_os() == 'freebsd'
		}
		'openbsd' {
			return p.normalized_target_os() == 'openbsd'
		}
		'netbsd' {
			return p.normalized_target_os() == 'netbsd'
		}
		'dragonfly' {
			return p.normalized_target_os() == 'dragonfly'
		}
		'android' {
			return p.normalized_target_os() == 'android'
		}
		'posix', 'unix' {
			return p.normalized_target_os() != 'windows'
		}
		'bsd' {
			tos := p.normalized_target_os()
			return tos == 'macos' || tos == 'freebsd' || tos == 'openbsd' || tos == 'netbsd'
				|| tos == 'dragonfly'
		}
		'x64' {
			$if x64 {
				return true
			}
			return false
		}
		'x32' {
			$if x32 {
				return true
			}
			return false
		}
		'amd64' {
			$if amd64 {
				return true
			}
			return false
		}
		'arm64', 'aarch64' {
			$if arm64 {
				return true
			}
			return false
		}
		'little_endian' {
			$if little_endian {
				return true
			}
			return false
		}
		'big_endian' {
			$if big_endian {
				return true
			}
			return false
		}
		'debug' {
			$if debug {
				return true
			}
			return false
		}
		'native' {
			return p.backend == 'arm64'
		}
		'builtin_write_buf_to_fd_should_use_c_write' {
			return p.backend == 'arm64'
		}
		'tinyc' {
			return p.backend == 'arm64'
		}
		'no_backtrace' {
			return p.backend == 'arm64' || name in p.user_defines
		}
		'gcboehm', 'gcboehm_opt', 'prealloc', 'autofree', 'no_bounds_checking', 'freestanding',
		'nofloat' {
			return name in p.user_defines
		}
		else {
			return name in p.user_defines
		}
	}
}

// comptime_optional_flag_value supports comptime optional flag value handling for pref.
pub fn comptime_optional_flag_value(p &Preferences, name string) bool {
	if name in p.user_defines {
		return true
	}
	return comptime_flag_value(p, name)
}

// comptime_pkgconfig_value supports comptime pkgconfig value handling for pref.
pub fn comptime_pkgconfig_value(name string) bool {
	result := os.execute('pkg-config --exists ${name}')
	return result.exit_code == 0
}