module main

import os
import v.pref
import v.util.version

const vvmrc_file_name = '.vvmrc'

const vvmrc_skip_env = 'V_SKIP_VVMRC'

const vvmrc_latest_aliases = ['latest', 'current']

const vvmrc_stop_paths = ['.git', '.hg', '.svn', '.v.mod.stop']

fn maybe_delegate_to_vvmrc(command string, prefs &pref.Preferences) {
	if os.getenv(vvmrc_skip_env) != '' {
		return
	}
	if !is_vvmrc_relevant_command(command, prefs) {
		return
	}
	target_path := if prefs.path != '' { prefs.path } else { command }
	vvmrc_path := find_project_vvmrc(target_path)
	if vvmrc_path == '' {
		return
	}
	requested_version := parse_vvmrc_version(os.read_file(vvmrc_path) or { '' })
	if requested_version == '' || is_vvmrc_latest_alias(requested_version) {
		return
	}
	normalized_requested_version := normalize_vvmrc_version(requested_version)
	if normalized_requested_version == normalize_vvmrc_version(version.v_version) {
		return
	}
	vversion_exe := resolve_vversion_executable(normalized_requested_version) or {
		eprintln('v: warning: `${vvmrc_path}` requests V `${requested_version}`, but no matching compiler executable was found. Continuing with V ${version.v_version}.')
		return
	}
	this_vexe := os.real_path(pref.vexe_path())
	if os.real_path(vversion_exe) == this_vexe {
		return
	}
	if prefs.is_verbose {
		eprintln('v: `.vvmrc` selected V `${requested_version}` from `${vvmrc_path}` => ${vversion_exe}')
	}
	mut process := os.new_process(vversion_exe)
	process.set_args(os.args[1..])
	mut envs := os.environ()
	envs[vvmrc_skip_env] = '1'
	envs['VEXE'] = vversion_exe
	process.set_environment(envs)
	process.wait()
	exit_code := if process.code == -1 { 1 } else { process.code }
	process.close()
	exit(exit_code)
}

fn is_vvmrc_relevant_command(command string, prefs &pref.Preferences) bool {
	if prefs.path in ['', '-'] {
		return false
	}
	if command in ['run', 'crun', 'build', 'build-module'] {
		return true
	}
	return command.ends_with('.v') || os.exists(command)
}

fn find_project_vvmrc(target_path string) string {
	if target_path in ['', '-'] {
		return ''
	}
	mut folder := if os.is_dir(target_path) { target_path } else { os.dir(target_path) }
	if folder == '' {
		folder = os.getwd()
	}
	mut current := os.real_path(folder)
	for _ in 0 .. 256 {
		vvmrc_path := os.join_path(current, vvmrc_file_name)
		if os.is_file(vvmrc_path) {
			return vvmrc_path
		}
		if has_vvmrc_stop_marker(current) {
			break
		}
		parent := os.dir(current)
		if parent in ['', current] {
			break
		}
		current = parent
	}
	return ''
}

fn has_vvmrc_stop_marker(folder string) bool {
	for stop_path in vvmrc_stop_paths {
		if os.exists(os.join_path(folder, stop_path)) {
			return true
		}
	}
	return false
}

fn parse_vvmrc_version(content string) string {
	for raw_line in content.split_into_lines() {
		line := raw_line.all_before('#').trim_space()
		if line != '' {
			return line
		}
	}
	return ''
}

fn normalize_vvmrc_version(version_name string) string {
	mut normalized := version_name.trim_space()
	if normalized.len > 1 && normalized[0] in [`v`, `V`] && normalized[1].is_digit() {
		normalized = normalized[1..]
	}
	return normalized
}

fn is_vvmrc_latest_alias(version_name string) bool {
	return normalize_vvmrc_version(version_name).to_lower_ascii() in vvmrc_latest_aliases
}

fn resolve_vversion_executable(version_name string) !string {
	raw_version := version_name.trim_space()
	if raw_version == '' {
		return error('empty version')
	}
	for candidate_name in versioned_v_executable_names(raw_version) {
		if found_path := os.find_abs_path_of_executable(candidate_name) {
			return found_path
		}
	}
	for candidate_path in versioned_v_executable_paths(raw_version) {
		if os.is_file(candidate_path) {
			return candidate_path
		}
	}
	return error('v executable for `${raw_version}` was not found')
}

fn versioned_v_executable_names(version_name string) []string {
	mut names := []string{}
	raw_version := version_name.trim_space()
	if raw_version == '' {
		return names
	}
	names << raw_version
	names << 'v${raw_version}'
	if raw_version.starts_with('v') {
		trimmed := raw_version[1..]
		if trimmed != '' {
			names << trimmed
		}
	}
	return unique_strings(names)
}

fn versioned_v_executable_paths(version_name string) []string {
	mut paths := []string{}
	normalized_version := normalize_vvmrc_version(version_name)
	if normalized_version == '' {
		return paths
	}
	paths << os.join_path('/usr/lib/v', normalized_version, 'bin', 'v')
	paths << os.join_path('/usr/local/bin', 'v${normalized_version}')
	for env_name in ['VVM_HOME', 'VVM_DIR'] {
		vvm_root := os.getenv(env_name).trim_space()
		if vvm_root == '' {
			continue
		}
		paths << os.join_path(vvm_root, normalized_version, 'bin', 'v')
		paths << os.join_path(vvm_root, 'versions', normalized_version, 'bin', 'v')
	}
	return unique_strings(paths)
}

fn unique_strings(items []string) []string {
	mut seen := map[string]bool{}
	mut result := []string{}
	for item in items {
		if item in seen {
			continue
		}
		seen[item] = true
		result << item
	}
	return result
}