// Copyright (c) 2020-2024 Joe Conigliaro. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
module builder

import os
import v2.pref

fn list_dir_entries(path string) []string {
	mut entries := os.ls(path) or { []string{} }
	entries.sort()
	return entries
}

pub fn get_v_files_from_dir(dir string, user_defines []string, target_os string) []string {
	if dir == '' {
		return []string{}
	}
	mod_files := list_dir_entries(dir)
	mut v_files := []string{}
	mut defaults := []string{}
	for file in mod_files {
		if file == '' {
			continue
		}
		// Include .v files (including .c.v), exclude .js.v and test files
		if !file.ends_with('.v') || file.ends_with('.js.v') || file.contains('_test.') {
			continue
		}
		// skip platform-specific files
		if file.contains('.arm64.') || file.contains('.arm32.') || file.contains('.amd64.') {
			continue
		}
		// Skip files specialized for a different target OS before parsing/type checking.
		if pref.file_has_incompatible_os_suffix(file, target_os) {
			continue
		}
		if file.ends_with('prealloc.c.v') && 'prealloc' !in user_defines {
			continue
		}
		// Conditional compilation files: _d_<feature> included when -d <feature> is set,
		// _notd_<feature> included when -d <feature> is NOT set.
		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
			}
		}
		path := os.join_path(dir, file)
		if path == '' {
			continue
		}
		// Collect _default.c.v files separately; they are only included when
		// no platform-specific variant exists (e.g. _darwin.c.v, _linux.c.v).
		if file.contains('default.c.v') {
			defaults << path
		} else {
			v_files << path
		}
	}
	// Add _default.c.v files only when no platform-specific variant was selected.
	for dfile in defaults {
		no_postfix := fname_without_platform_postfix(dfile)
		mut has_specialized := false
		for vf in v_files {
			if fname_without_platform_postfix(vf) == no_postfix {
				has_specialized = true
				break
			}
		}
		if !has_specialized {
			v_files << dfile
		}
	}
	return v_files
}

// fname_without_platform_postfix strips the platform-specific suffix from a file path,
// so that e.g. "free_memory_impl_darwin.c.v" and "free_memory_impl_default.c.v" both
// map to the same key, allowing detection of specialized vs default variants.
fn fname_without_platform_postfix(file string) string {
	return file.replace_each([
		'default.c.v',
		'_',
		'windows.c.v',
		'_',
		'linux.c.v',
		'_',
		'darwin.c.v',
		'_',
		'macos.c.v',
		'_',
		'android.c.v',
		'_',
		'android_outside_termux.c.v',
		'_',
		'termux.c.v',
		'_',
		'ios.c.v',
		'_',
		'freebsd.c.v',
		'_',
		'openbsd.c.v',
		'_',
		'netbsd.c.v',
		'_',
		'dragonfly.c.v',
		'_',
		'bsd.c.v',
		'_',
		'solaris.c.v',
		'_',
		'qnx.c.v',
		'_',
		'serenity.c.v',
		'_',
		'plan9.c.v',
		'_',
		'vinix.c.v',
		'_',
		'nix.c.v',
		'_',
	])
}

// extract_define_feature extracts the feature name from a _d_ or _notd_ filename.
// e.g. "parse_d_parallel.v" with marker "_d_" returns "parallel"
// e.g. "array_notd_gcboehm_opt.v" with marker "_notd_" returns "gcboehm_opt"
fn extract_define_feature(file string, marker string) string {
	idx := file.index(marker) or { return '' }
	rest := file[idx + marker.len..]
	// Strip .v or .c.v suffix
	feature := if rest.ends_with('.c.v') {
		rest[..rest.len - 4]
	} else if rest.ends_with('.v') {
		rest[..rest.len - 2]
	} else {
		rest
	}
	return feature
}