module pref

import os

pub fn (prefs &Preferences) should_compile_filtered_files(dir string, files_ []string) []string {
	mut res := []string{}
	mut files := files_.clone()
	files.sort()
	mut all_v_files := []string{}
	files_loop: for file in files {
		if !file.ends_with('.v') && !file.ends_with('.vh') {
			continue
		}
		if file.ends_with('_test.v')
			|| file.all_before_last('.v').all_before_last('.').ends_with('_test') {
			continue
		}
		mut is_d_notd_file := false
		if file.contains('_d_') {
			is_d_notd_file = true
			if prefs.compile_defines_all.len == 0 {
				continue
			}
			mut allowed := false
			for cdefine in prefs.compile_defines {
				file_postfixes := ['_d_${cdefine}.v', '_d_${cdefine}.c.v']
				for file_postfix in file_postfixes {
					if file.ends_with(file_postfix) {
						allowed = true
						break
					}
				}
				if allowed {
					break
				}
			}
			if !allowed {
				continue
			}
		}
		if file.contains('_notd_') {
			is_d_notd_file = true
			mut allowed := true
			for cdefine in prefs.compile_defines {
				file_postfixes := ['_notd_${cdefine}.v', '_notd_${cdefine}.c.v']
				for file_postfix in file_postfixes {
					if file.ends_with(file_postfix) {
						allowed = false
						break
					}
				}
				if !allowed {
					break
				}
			}
			if !allowed {
				continue
			}
		}
		if prefs.backend in [.c, .interpret] && !is_d_notd_file && !prefs.should_compile_c(file) {
			continue
		}
		if prefs.backend.is_js() && !prefs.should_compile_js(file) {
			continue
		}
		if !prefs.backend.is_js() && !prefs.should_compile_asm(file) {
			continue
		}
		if prefs.backend == .wasm && !prefs.should_compile_wasm(file) {
			continue
		}
		if file.starts_with('.#') {
			continue
		}
		if !prefs.prealloc && !prefs.output_cross_c && file.ends_with('prealloc.c.v') {
			continue
		}
		if prefs.nofloat && file.ends_with('float.c.v') {
			continue
		}
		if prefs.exclude.len > 0 {
			full_file_path := os.join_path(dir, file)
			for epattern in prefs.exclude {
				if full_file_path.match_glob(epattern) {
					continue files_loop
				}
			}
		}
		all_v_files << os.join_path(dir, file)
	}

	mut defaults := []string{}
	mut fnames_no_postfixes := map[string][]string{}
	for file in all_v_files {
		if file.contains('default.c.v') {
			defaults << file
		} else {
			res << file
			no_postfix_key := fname_without_platform_postfix(file)
			mut candidates := fnames_no_postfixes[no_postfix_key]
			candidates << file
			fnames_no_postfixes[no_postfix_key] = candidates
		}
	}
	for file in defaults {
		no_postfix_key := fname_without_platform_postfix(file)
		if no_postfix_key in fnames_no_postfixes {
			if prefs.is_verbose {
				println('>>> should_compile_filtered_files: skipping _default.c.v file ${file} ; the specialized versions are: ${fnames_no_postfixes[no_postfix_key]}')
			}
			continue
		}
		res << file
	}
	res = prefs.filter_bsd_specific_files(res)
	if prefs.is_verbose {
		// println('>>> prefs: ${prefs}')
		println('>>> should_compile_filtered_files: res: ${res}')
	}
	return res
}

const platform_specific_postfixes = [
	'_android_outside_termux.c.v',
	'_wasm32_emscripten.c.v',
	'_wasm32_emscripten.v',
	'_dragonfly.c.v',
	'_dragonfly.v',
	'_windows.c.v',
	'_windows.v',
	'_freebsd.c.v',
	'_freebsd.v',
	'_openbsd.c.v',
	'_openbsd.v',
	'_netbsd.c.v',
	'_netbsd.v',
	'_solaris.c.v',
	'_serenity.c.v',
	'_android.c.v',
	'_termux.c.v',
	'_darwin.c.v',
	'_darwin.v',
	'_macos.c.v',
	'_macos.v',
	'_linux.c.v',
	'_linux.v',
	'_default.c.v',
	'_bsd.c.v',
	'_bsd.v',
	'_nix.c.v',
	'_nix.v',
	'_ios.c.v',
	'_ios.v',
	'_qnx.c.v',
	'_plan9.c.v',
	'_vinix.c.v',
	'_haiku.c.v',
]

fn fname_without_platform_postfix(file string) string {
	for postfix in platform_specific_postfixes {
		if file.ends_with(postfix) {
			return file[..file.len - postfix.len]
		}
	}
	return file
}

struct BsdSpecificFiles {
mut:
	has_bsd   bool
	has_exact bool
}

fn (prefs &Preferences) filter_bsd_specific_files(files []string) []string {
	if !prefs.os.is_bsd_target() {
		return files
	}
	mut variants := map[string]BsdSpecificFiles{}
	for file in files {
		kind := prefs.bsd_specific_file_kind(file)
		if kind == '' {
			continue
		}
		key := fname_without_platform_postfix(file)
		mut info := variants[key]
		if kind == 'bsd' {
			info.has_bsd = true
		}
		if kind == 'exact' {
			info.has_exact = true
		}
		variants[key] = info
	}
	mut res := []string{}
	for file in files {
		kind := prefs.bsd_specific_file_kind(file)
		if kind == '' {
			res << file
			continue
		}
		info := variants[fname_without_platform_postfix(file)]
		if kind == 'nix' && info.has_bsd {
			if prefs.is_verbose {
				println('>>> should_compile_filtered_files: skipping _nix file ${file} ; _bsd is more specific')
			}
			continue
		}
		if kind == 'bsd' && info.has_exact {
			if prefs.is_verbose {
				println('>>> should_compile_filtered_files: skipping _bsd file ${file} ; exact BSD target is more specific')
			}
			continue
		}
		res << file
	}
	return res
}

fn (prefs &Preferences) bsd_specific_file_kind(file string) string {
	if file.ends_with('_nix.c.v') || file.ends_with('_nix.v') {
		return 'nix'
	}
	if file.ends_with('_bsd.c.v') || file.ends_with('_bsd.v') {
		return 'bsd'
	}
	if prefs.os == .macos && (file.ends_with('_darwin.c.v') || file.ends_with('_darwin.v')
		|| file.ends_with('_macos.c.v') || file.ends_with('_macos.v')) {
		return 'exact'
	}
	if prefs.os == .freebsd && (file.ends_with('_freebsd.c.v') || file.ends_with('_freebsd.v')) {
		return 'exact'
	}
	if prefs.os == .openbsd && (file.ends_with('_openbsd.c.v') || file.ends_with('_openbsd.v')) {
		return 'exact'
	}
	if prefs.os == .netbsd && (file.ends_with('_netbsd.c.v') || file.ends_with('_netbsd.v')) {
		return 'exact'
	}
	if prefs.os == .dragonfly
		&& (file.ends_with('_dragonfly.c.v') || file.ends_with('_dragonfly.v')) {
		return 'exact'
	}
	return ''
}

// TODO: Rework this using is_target_of()
pub fn (prefs &Preferences) should_compile_c(file string) bool {
	if file.ends_with('.js.v') || file.ends_with('.wasm.v') {
		// Probably something like `a.js.v` or `a.wasm.v`.
		return false
	}
	if prefs.is_bare && file.ends_with('.freestanding.v') {
		return true
	}
	if prefs.os == .all {
		return true
	}
	if file.ends_with('_native.v') {
		return false
	}
	if prefs.building_v && prefs.output_cross_c && file.ends_with('_windows.v') {
		// TODO: temp hack to make msvc_windows.v work with -os cross
		return true
	}
	if prefs.os == .windows && (file.ends_with('_nix.c.v') || file.ends_with('_nix.v')) {
		return false
	}
	if prefs.os != .windows && (file.ends_with('_windows.c.v') || file.ends_with('_windows.v')) {
		return false
	}

	if prefs.os != .linux && (file.ends_with('_linux.c.v') || file.ends_with('_linux.v')) {
		return false
	}

	if prefs.os != .macos && (file.ends_with('_darwin.c.v') || file.ends_with('_darwin.v')) {
		return false
	}
	if prefs.os != .macos && (file.ends_with('_macos.c.v') || file.ends_with('_macos.v')) {
		return false
	}

	if prefs.os != .ios && (file.ends_with('_ios.c.v') || file.ends_with('_ios.v')) {
		return false
	}
	if !prefs.os.is_bsd_target() && (file.ends_with('_bsd.c.v') || file.ends_with('_bsd.v')) {
		return false
	}
	if prefs.os != .freebsd && (file.ends_with('_freebsd.c.v') || file.ends_with('_freebsd.v')) {
		return false
	}
	if prefs.os != .openbsd && (file.ends_with('_openbsd.c.v') || file.ends_with('_openbsd.v')) {
		return false
	}
	if prefs.os != .netbsd && (file.ends_with('_netbsd.c.v') || file.ends_with('_netbsd.v')) {
		return false
	}
	if prefs.os != .dragonfly
		&& (file.ends_with('_dragonfly.c.v') || file.ends_with('_dragonfly.v')) {
		return false
	}
	if prefs.os != .solaris && file.ends_with('_solaris.c.v') {
		return false
	}
	if prefs.os != .qnx && file.ends_with('_qnx.c.v') {
		return false
	}
	if prefs.os != .serenity && file.ends_with('_serenity.c.v') {
		return false
	}
	if prefs.os != .plan9 && file.ends_with('_plan9.c.v') {
		return false
	}
	if prefs.os != .vinix && file.ends_with('_vinix.c.v') {
		return false
	}
	if prefs.os in [.android, .termux] {
		// Note: Termux is running natively on Android devices, but the compilers there (clang) usually do not have access
		// to the Android SDK. The code here ensures that you can have `_termux.c.v` and `_android_outside_termux.c.v` postfixes,
		// to target both the cross compilation case (where the SDK headers are used and available), and the Termux case,
		// where the Android SDK is not used.
		if file.ends_with('_android.c.v') {
			// common case, should compile for both cross android and termux
			// eprintln('prefs.os: ${prefs.os} | file: ${file} | common')
			return true
		}
		if file.ends_with('_android_outside_termux.c.v') {
			// compile code that targets Android, but NOT Termux (i.e. the SDK is available)
			// eprintln('prefs.os: ${prefs.os} | file: ${file} | android_outside_termux')
			return prefs.os == .android
		}
		if file.ends_with('_termux.c.v') {
			// compile Termux specific code
			// eprintln('prefs.os: ${prefs.os} | file: ${file} | termux specific')
			return prefs.os == .termux
		}
	} else if file.ends_with('_android.c.v') || file.ends_with('_termux.c.v')
		|| file.ends_with('_android_outside_termux.c.v') {
		return false
	}
	if prefs.os != .wasm32_emscripten
		&& (file.ends_with('_wasm32_emscripten.c.v') || file.ends_with('_wasm32_emscripten.v')) {
		return false
	}
	return true
}

pub fn (prefs &Preferences) should_compile_asm(path string) bool {
	if path.count('.') != 2 || path.ends_with('c.v') || path.ends_with('js.v') {
		return true
	}
	file := path.all_before_last('.v')
	arch := arch_from_string(file.all_after_last('.')) or { Arch._auto }

	if arch != prefs.arch && prefs.arch != ._auto && arch != ._auto {
		return false
	}
	file_os := os_from_string(file.all_after_last('_').all_before('.')) or { OS._auto }

	if file_os != prefs.os && prefs.os != ._auto && file_os != ._auto {
		return false
	}
	return true
}

pub fn (prefs &Preferences) should_compile_js(file string) bool {
	if !file.ends_with('.js.v') && file.split('.').len > 2 {
		// Probably something like `a.c.v`.
		return false
	}
	return true
}

pub fn (prefs &Preferences) should_compile_wasm(file string) bool {
	if !file.ends_with('.wasm.v') && file.count('.') >= 2 {
		// not .wasm.v not just .v something else like .c.v
		return false
	}
	return true
}

// is_target_of returns true if this_os is included in the target specified
// for example, 'nix' is true for Linux and FreeBSD but not Windows
pub fn (this_os OS) is_target_of(target string) bool {
	if this_os == .all {
		return true
	}
	// Note: Termux is running natively on Android devices, but the compilers there (clang) usually do not have access
	// to the Android SDK. The code here ensures that you can have `_termux.c.v` and `_android_outside_termux.c.v` postfixes,
	// to target both the cross compilation case (where the SDK headers are used and available), and the Termux case,
	// where the Android SDK is not used.
	// 'nix' means "all but Windows"
	if (this_os == .windows && target == 'nix')
		|| (this_os != .windows && target == 'windows')
		|| (this_os != .linux && target == 'linux')
		|| (this_os != .macos && target in ['darwin', 'macos', 'mac'])
		|| (!this_os.is_bsd_target() && target == 'bsd')
		|| (this_os != .ios && target == 'ios')
		|| (this_os != .freebsd && target == 'freebsd')
		|| (this_os != .openbsd && target == 'openbsd')
		|| (this_os != .netbsd && target == 'netbsd')
		|| (this_os != .dragonfly && target == 'dragonfly')
		|| (this_os != .solaris && target == 'solaris')
		|| (this_os != .qnx && target == 'qnx')
		|| (this_os != .serenity && target == 'serenity')
		|| (this_os != .plan9 && target == 'plan9')
		|| (this_os != .vinix && target == 'vinix')
		|| (this_os != .android && target in ['android', 'android_outside_termux'])
		|| (this_os != .termux && target == 'termux') {
		return false
	}
	return true
}

fn (this_os OS) is_bsd_target() bool {
	return this_os in [.macos, .freebsd, .openbsd, .netbsd, .dragonfly]
}