// 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 pref

import os
import os.cmdline

pub enum Backend {
	v      // V source output (default)
	eval   // AST interpreter
	cleanc // Clean C backend (AST -> C)
	c      // SSA -> C backend
	x64    // Native x64/AMD64 backend
	arm64  // Native ARM64 backend
}

pub enum Arch {
	auto // Auto-detect based on OS
	x64
	arm64
}

// GarbageCollectionMode controls which garbage collector is used.
// Translated from Go's runtime GC, the `vgc` mode provides a concurrent
// tri-color mark-and-sweep collector written in pure V.
pub enum GarbageCollectionMode {
	no_gc // no garbage collection
	vgc   // V GC: concurrent tri-color mark-and-sweep (translated from Go's runtime GC)
	boehm // Boehm-Demers-Weiser conservative GC (legacy)
}

pub struct Preferences {
pub mut:
	debug                 bool
	verbose               bool
	ownership             bool // -ownership: enable ownership checking for strings
	skip_genv             bool
	skip_builtin          bool
	skip_imports          bool
	skip_type_check       bool // Skip type checking phase (for backends that don't need it yet)
	no_parallel           bool // when true, run type check sequentially (default: parallel)
	no_parallel_transform bool // when true, run transform sequentially (default: parallel)
	no_cache              bool // Disable build cache
	no_markused           bool // Disable markused stage and dead-function pruning
	show_cc               bool // Print C compiler command(s)
	stats                 bool // Print extended statistics
	print_parsed_files    bool // Print all parsed files grouped by full/.vh parse mode
	keep_c                bool // Keep generated C file after compilation
	use_context_allocator bool // Use context allocator for heap allocations (enables profiling)
	is_shared_lib         bool // Compile to shared library (.dylib/.so) for live reload
	no_optimize           bool = true // skip SSA optimization (mem2reg, phi elimination); cleared by -prod
	is_prod               bool                  // -prod: enable SSA optimization + -O3 -flto for C compiler
	prealloc              bool                  // -prealloc: use arena allocation (bump-pointer, not thread-safe)
	gc_mode               GarbageCollectionMode // Garbage collection mode (-gc flag)
	backend               Backend
	arch                  Arch   = .auto
	target_os             string = os.user_os()
	output_cross_c        bool     // -os cross: keep generated C portable
	freestanding          bool     // -freestanding: target a platform contract without an OS runtime
	freestanding_hooks    []string // -fhooks: explicit freestanding platform capabilities
	macos_tiny            bool = true // -no-mos-tiny: disable the automatic macOS x64 tiny object path
	output_file           string
	printfn_list          []string // List of function names whose generated C source should be printed
	user_defines          []string // All active comptime flags, including compiler-synthesized flags.
	explicit_user_defines []string // User-defined comptime flags from explicit -d <name> only.
	hot_fn                string   // Extract raw machine code for this function only (hot reload)
	single_backend        bool     // Only include the selected backend (strip other backends from binary)
	eval_runtime_args     []string // Program argv exposed to the eval backend
	ccompiler             string   // C compiler override (-cc flag)
pub:
	vroot         string = detect_vroot()
	vmodules_path string = os.vmodules_dir()
}

fn dir_exists(path string) bool {
	if path.len == 0 {
		return false
	}
	if os.is_dir(path) {
		return true
	}
	_ := os.ls(path) or { return false }
	return true
}

fn detect_vroot_from(start string) string {
	if start.len == 0 {
		return ''
	}
	mut dir := start
	// Avoid os.abs_path during bootstrap; normalize relative paths manually.
	if !os.is_abs_path(dir) {
		cwd := os.getwd()
		if cwd.len > 0 {
			dir = os.join_path(cwd, dir)
		}
	}
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	dir = os.dir(dir)
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	dir = os.dir(dir)
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	dir = os.dir(dir)
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	dir = os.dir(dir)
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	dir = os.dir(dir)
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	dir = os.dir(dir)
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	dir = os.dir(dir)
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	dir = os.dir(dir)
	if dir_exists(os.join_path(dir, 'vlib', 'builtin')) {
		return dir
	}
	return ''
}

fn detect_vroot() string {
	// First prefer the compile-time module root when it points to a valid
	// V source tree. This keeps self-host binaries stable during bootstrapping.
	compile_time_root := @VMODROOT
	if compile_time_root.len > 0 {
		// Trust @VMODROOT without runtime validation. During bootstrapping
		// (v2 → v3 via ARM64), os.join_path/os.is_dir may not work correctly
		// in the native binary, but the compile-time root is always correct.
		return compile_time_root
	}
	// Prefer deriving from executable path: <vroot>/cmd/v2/v3.
	if os.args.len > 0 && os.args[0].len > 0 {
		vroot := detect_vroot_from(os.args[0])
		if vroot.len > 0 {
			return vroot
		}
	}
	// Fallback to current directory ancestry.
	cwd := os.getwd()
	vroot := detect_vroot_from(cwd)
	if vroot.len > 0 {
		return vroot
	}
	// Final fallback: keep old behavior for unusual bootstrap contexts.
	if os.args.len > 0 && os.args[0].len > 0 {
		if os.is_abs_path(os.args[0]) {
			return os.dir(os.args[0])
		}
		return cwd
	}
	return cwd
}

pub fn new_preferences() Preferences {
	return Preferences{
		backend: .cleanc
	}
}

pub fn (p &Preferences) target_os_or_host() string {
	if p == unsafe { nil } || p.target_os == '' {
		return os.user_os()
	}
	return p.target_os
}

pub fn (p &Preferences) normalized_target_os() string {
	return normalize_target_os_name(p.target_os_or_host())
}

pub fn (p &Preferences) is_cross_target() bool {
	return p != unsafe { nil } && (p.output_cross_c || p.normalized_target_os() == 'cross')
}

pub fn (p &Preferences) is_freestanding() bool {
	return p != unsafe { nil } && p.freestanding
}

pub fn (p &Preferences) can_compile_cleanc_locally() bool {
	if p == unsafe { nil } {
		return true
	}
	if p.is_freestanding() {
		return false
	}
	if p.is_cross_target() {
		return true
	}
	return p.normalized_target_os() == normalize_target_os_name(os.user_os())
}

pub fn (p &Preferences) can_run_target_binary_locally() bool {
	if p == unsafe { nil } {
		return true
	}
	if p.is_freestanding() {
		return false
	}
	if p.backend == .cleanc && p.is_cross_target() {
		return true
	}
	if p.normalized_target_os() != normalize_target_os_name(os.user_os()) {
		return false
	}
	return true
}

pub fn (p &Preferences) source_filter_target_os() string {
	if p == unsafe { nil } {
		return normalize_target_os_name(os.user_os())
	}
	if p.is_cross_target() {
		return normalize_target_os_name(os.user_os())
	}
	return p.target_os_or_host()
}

pub fn (p &Preferences) freestanding_hook_list() []string {
	if p == unsafe { nil } {
		return []string{}
	}
	return p.freestanding_hooks.clone()
}

pub fn (p &Preferences) has_freestanding_hooks() bool {
	return p != unsafe { nil } && p.freestanding_hooks.len > 0
}

pub fn (p &Preferences) has_freestanding_hook(name string) bool {
	if p == unsafe { nil } {
		return false
	}
	normalized := normalize_freestanding_hook_name(name) or { return false }
	return normalized in p.freestanding_hooks
}

fn normalize_cli_target_os(target_os string) string {
	normalized := normalize_target_os_name(target_os)
	match normalized {
		'linux', 'macos', 'windows', 'cross', 'none', 'freebsd', 'openbsd', 'netbsd', 'dragonfly',
		'android', 'termux', 'ios', 'solaris', 'qnx', 'serenity', 'plan9', 'vinix' {
			return normalized
		}
		else {
			eprintln('error: unknown target OS `${target_os}`. Valid targets include: linux, macos, windows, cross, none, freebsd, openbsd, netbsd, dragonfly, android, termux, ios, solaris, qnx, serenity, plan9, vinix')
			exit(1)
		}
	}
}

fn validate_target_contract(target_os string, freestanding bool) {
	if target_os == 'none' && !freestanding {
		eprintln('error: -os none requires -freestanding')
		exit(1)
	}
	if target_os == 'cross' && freestanding {
		eprintln('error: -freestanding -os cross is not supported; use -os none for pure freestanding targets')
		exit(1)
	}
}

fn validate_macos_tiny_flag_contract(options []string, target_os string) ! {
	if '-no-mos-tiny' in options && target_os != 'macos' {
		return error('-no-mos-tiny requires a macOS target; use -os macos or run on a macOS host')
	}
}

fn normalize_freestanding_hook_name(name string) ?string {
	normalized := name.trim_space().to_lower()
	return match normalized {
		'output', 'panic', 'alloc' {
			normalized
		}
		else {
			none
		}
	}
}

fn append_freestanding_hook(mut hooks []string, hook string) {
	normalized := normalize_freestanding_hook_name(hook) or {
		eprintln('error: unknown freestanding hook `${hook}`. Valid hooks: output, panic, alloc, minimal')
		exit(1)
	}
	if normalized !in hooks {
		hooks << normalized
	}
}

fn parse_freestanding_hooks(value string) []string {
	mut hooks := []string{}
	for raw_part in value.split(',') {
		part := raw_part.trim_space()
		if part == '' {
			continue
		}
		if part == 'minimal' {
			for hook in ['output', 'panic', 'alloc'] {
				append_freestanding_hook(mut hooks, hook)
			}
			continue
		}
		append_freestanding_hook(mut hooks, part)
	}
	return hooks
}

fn add_freestanding_hook_defines(mut defines []string, hooks []string) {
	if hooks.len == 0 {
		return
	}
	if 'freestanding_hooks' !in defines {
		defines << 'freestanding_hooks'
	}
	for hook in hooks {
		for define in ['freestanding_${hook}', 'freestanding_hooks_${hook}'] {
			if define !in defines {
				defines << define
			}
		}
	}
}

pub fn source_files_from_args(args []string) []string {
	options_with_values := ['-backend', '-b', '-o', '-output', '-arch', '-printfn', '-gc', '-d',
		'-hot-fn', '-cc', '-os', '-fhooks']
	mut files := []string{}
	mut skip_next := false
	for arg in args {
		if arg == '--' {
			break
		}
		if skip_next {
			skip_next = false
			continue
		}
		if arg.starts_with('-') {
			if arg in options_with_values {
				skip_next = true
			}
			continue
		}
		files << arg
	}
	return files
}

// new_preferences_from_args parses full args list including option values
pub fn new_preferences_from_args(args []string) Preferences {
	// Default backend is cleanc
	default_backend := 'cleanc'
	mut backend_str_long := cmdline.option(args, '-backend', '')
	if backend_str_long.len == 0 {
		backend_str_long = ''
	}
	mut backend_str_short := cmdline.option(args, '-b', '')
	if backend_str_short.len == 0 {
		backend_str_short = ''
	}
	backend_str := if backend_str_long.len > 0 {
		backend_str_long
	} else if backend_str_short.len > 0 {
		backend_str_short
	} else {
		default_backend
	}
	mut backend := Backend.cleanc
	match backend_str {
		'eval' {
			backend = .eval
		}
		'cleanc' {
			backend = .cleanc
		}
		'c' {
			backend = .c
		}
		'v' {
			backend = .v
		}
		'arm64' {
			backend = .arm64
		}
		'x64' {
			backend = .x64
		}
		else {
			eprintln('error: unknown backend `${backend_str}`. Valid backends: eval, cleanc, c, v, arm64, x64')
			exit(1)
		}
	}

	mut arch_str := cmdline.option(args, '-arch', 'auto')
	if arch_str.len == 0 {
		arch_str = 'auto'
	}
	mut arch := Arch.auto
	match arch_str {
		'auto' {
			arch = .auto
		}
		'x64' {
			arch = .x64
		}
		'arm64' {
			arch = .arm64
		}
		else {
			eprintln('error: unknown architecture `${arch_str}`. Valid architectures: auto, x64, arm64')
			exit(1)
		}
	}

	output_file := cmdline.option(args, '-o', cmdline.option(args, '-output', ''))
	ccompiler := cmdline.option(args, '-cc', '')
	target_os_arg := cmdline.option(args, '-os', '')
	freestanding_hooks_arg := cmdline.option(args, '-fhooks', '')
	// Without -os, V2 targets the host OS. -os is an explicit target override;
	// -os cross and -freestanding express separate portable/platform contracts.
	normalized_target_os := if target_os_arg.len > 0 {
		normalize_cli_target_os(target_os_arg)
	} else {
		normalize_target_os_name(os.user_os())
	}
	output_cross_c := normalized_target_os == 'cross'

	// Parse -printfn option (comma-separated list of function names to print)
	mut printfn_str := cmdline.option(args, '-printfn', '')
	if printfn_str.len == 0 {
		printfn_str = ''
	}
	printfn_list := if printfn_str.len > 0 { printfn_str.split(',') } else { []string{} }

	// Parse -d <name> comptime defines (can be specified multiple times)
	user_defines := cmdline.options(args, '-d')

	// Parse -hot-fn <name> for hot code reloading
	mut hot_fn_str := cmdline.option(args, '-hot-fn', '')
	if hot_fn_str.len == 0 {
		hot_fn_str = ''
	}

	// Parse -gc <mode> for garbage collection
	gc_mode_str := cmdline.option(args, '-gc', '')
	mut gc_mode := GarbageCollectionMode.no_gc
	mut gc_defines := []string{}
	match gc_mode_str {
		'', 'none' {
			gc_mode = .no_gc
		}
		'vgc' {
			gc_mode = .vgc
			gc_defines << 'vgc'
		}
		'boehm' {
			gc_mode = .boehm
			gc_defines << 'gcboehm'
			gc_defines << 'gcboehm_full'
			gc_defines << 'gcboehm_opt'
		}
		else {
			eprintln('error: unknown garbage collection mode `-gc ${gc_mode_str}`')
			eprintln('  `-gc vgc` .............. V GC: concurrent tri-color mark-and-sweep (translated from Go)')
			eprintln('  `-gc boehm` ............ Boehm-Demers-Weiser conservative GC')
			eprintln('  `-gc none` ............. no garbage collection (default)')
			exit(1)
		}
	}

	mut all_defines := user_defines.clone()
	all_defines << gc_defines
	if output_cross_c && 'cross' !in all_defines {
		all_defines << 'cross'
	}
	if '-prealloc' in args {
		all_defines << 'prealloc'
	}
	freestanding := '-freestanding' in args || '--freestanding' in args
	validate_target_contract(normalized_target_os, freestanding)
	freestanding_hooks := parse_freestanding_hooks(freestanding_hooks_arg)
	if freestanding_hooks.len > 0 && !freestanding {
		eprintln('error: -fhooks requires -freestanding')
		exit(1)
	}
	if freestanding && 'freestanding' !in all_defines {
		all_defines << 'freestanding'
	}
	add_freestanding_hook_defines(mut all_defines, freestanding_hooks)

	options := cmdline.only_options(args)
	validate_macos_tiny_flag_contract(options, normalized_target_os) or {
		eprintln('error: ${err.msg()}')
		exit(1)
	}
	macos_tiny := '-no-mos-tiny' !in options

	// Parse -ownership flag (must be after options is declared)
	mut ownership := false
	$if ownership ? {
		ownership = '-ownership' in options
		if ownership {
			all_defines << 'ownership'
		}
	}

	// Validate flags: error on unknown options
	known_flags_with_values := ['-backend', '-b', '-o', '-output', '-arch', '-printfn', '-gc',
		'-d', '-hot-fn', '-cc', '-os', '-fhooks']
	mut known_boolean_flags := ['--debug', '--verbose', '-v', '--skip-genv', '--skip-builtin',
		'--skip-imports', '--skip-type-check', '-no-parallel', '--no-parallel', '-nocache',
		'--nocache', '-nomarkused', '--nomarkused', '-showcc', '--showcc', '-stats', '--stats',
		'-print-parsed-files', '--print-parsed-files', '-keepc', '--profile-alloc', '-profile-alloc',
		'-enable-globals', '--enable-globals', '-shared', '--shared', '-O0', '--single-backend',
		'-single-backend', '-prod', '-prealloc', '-freestanding', '--freestanding', '-no-mos-tiny']
	$if ownership ? {
		known_boolean_flags << '-ownership'
	}
	for opt in options {
		if opt !in known_flags_with_values && opt !in known_boolean_flags {
			eprintln('error: unknown flag `${opt}`')
			eprintln('')
			eprintln('Usage: v2 [options] <file.v>')
			eprintln('')
			eprintln('Options:')
			eprintln('  -o <file>              Output file name')
			eprintln('  -b <name>              Backend: eval, cleanc, c, v, arm64, x64 (default: cleanc; omit for cleanc)')
			eprintln('                         -backend <name> is accepted as a compatibility alias')
			eprintln('  -arch <name>           Architecture: auto, x64, arm64 (default: auto)')
			eprintln('  -os <target>           Override target OS (default: host OS): linux, macos, windows, termux, cross, none')
			eprintln('  -printfn <names>       Print generated C for functions (comma-separated)')
			eprintln('  -stats, --stats        Print compilation statistics')
			eprintln('  -nocache, --nocache    Disable build cache')
			eprintln('  -d <name>              Define a comptime flag')
			eprintln('  -enable-globals        Accepted for v1 compatibility')
			eprintln('  -prod                  Production build: enable SSA optimization + -O3 -flto')
			eprintln('  -prealloc              Use arena allocation (faster, not thread-safe)')
			eprintln('  -freestanding          Generate for a freestanding platform contract')
			eprintln('  -fhooks <values>       Advanced freestanding hooks for --skip-builtin --skip-type-check stubs')
			eprintln('                         Values: output, panic, alloc, minimal')
			eprintln('  -no-mos-tiny           Disable macOS x64 tiny object output')
			eprintln('  -O0                    Skip SSA optimization (default; use -prod to enable)')
			$if ownership ? {
				eprintln('  -ownership             Enable ownership checking for strings')
			}
			eprintln('  --debug                Enable debug mode')
			eprintln('  -v, --verbose          Enable verbose output')
			eprintln('  -cc <compiler>         C compiler to use (default: tcc, fallback: cc)')
			eprintln('  -showcc, --showcc      Print C compiler command')
			eprintln('  -keepc                 Keep generated C file')
			eprintln('  -no-parallel, --no-parallel')
			eprintln('                         Disable parallel type check and transform')
			exit(1)
		}
	}

	implicit_skip_builtin := freestanding && freestanding_hooks.len == 0
	return Preferences{
		debug:                 '--debug' in options
		verbose:               '--verbose' in options || '-v' in options
		skip_genv:             '--skip-genv' in options
		skip_builtin:          '--skip-builtin' in options || implicit_skip_builtin
		skip_imports:          '--skip-imports' in options
		skip_type_check:       '--skip-type-check' in options
		no_parallel:           '-no-parallel' in options || '--no-parallel' in options
		no_parallel_transform: '-no-parallel' in options || '--no-parallel' in options
		no_cache:              '-nocache' in options || '--nocache' in options
		no_markused:           '-nomarkused' in options || '--nomarkused' in options
		show_cc:               '-showcc' in options || '--showcc' in options
		stats:                 '-stats' in options || '--stats' in options
		print_parsed_files:    '-print-parsed-files' in options || '--print-parsed-files' in options
		keep_c:                '-keepc' in options
		use_context_allocator: '--profile-alloc' in options || '-profile-alloc' in options
		is_shared_lib:         '-shared' in options || '--shared' in options
		no_optimize:           '-O0' in options || '-prod' !in options
		is_prod:               '-prod' in options
		prealloc:              '-prealloc' in options
		single_backend:        '--single-backend' in options || '-single-backend' in options
		ownership:             ownership
		gc_mode:               gc_mode
		backend:               backend
		arch:                  arch
		target_os:             normalized_target_os
		output_cross_c:        output_cross_c
		freestanding:          freestanding
		freestanding_hooks:    freestanding_hooks
		macos_tiny:            macos_tiny
		output_file:           output_file
		printfn_list:          printfn_list
		user_defines:          all_defines
		explicit_user_defines: user_defines.clone()
		hot_fn:                hot_fn_str
		ccompiler:             ccompiler
		vroot:                 detect_vroot()
		vmodules_path:         os.vmodules_dir()
	}
}

fn target_os_from_option_tokens(options []string) string {
	for opt in options {
		if opt.starts_with('--os-') {
			return normalize_cli_target_os(opt.all_after('--os-'))
		}
		if opt.starts_with('os-') {
			return normalize_cli_target_os(opt.all_after('os-'))
		}
	}
	return normalize_target_os_name(os.user_os())
}

fn freestanding_hooks_from_option_tokens(options []string) []string {
	mut hooks := []string{}
	for opt in options {
		if opt.starts_with('--fhooks-') {
			for hook in parse_freestanding_hooks(opt.all_after('--fhooks-')) {
				append_freestanding_hook(mut hooks, hook)
			}
		} else if opt.starts_with('fhooks-') {
			for hook in parse_freestanding_hooks(opt.all_after('fhooks-')) {
				append_freestanding_hook(mut hooks, hook)
			}
		}
	}
	return hooks
}

pub fn new_preferences_using_options(options []string) Preferences {
	// Default backend based on OS: macOS defaults to arm64, others to x64
	mut backend := if os.user_os() == 'macos' { Backend.arm64 } else { Backend.x64 }
	if '--eval' in options || 'eval' in options {
		backend = .eval
	} else if '--cleanc' in options || 'cleanc' in options {
		backend = .cleanc
	} else if '--c' in options || 'c' in options {
		backend = .c
	} else if '--v' in options || 'v' in options {
		backend = .v
	} else if '--arm64' in options || 'arm64' in options {
		backend = .arm64
	} else if '--x64' in options || 'x64' in options {
		backend = .x64
	}

	mut arch := Arch.auto
	if '--arch-x64' in options {
		arch = .x64
	} else if '--arch-arm64' in options {
		arch = .arm64
	}
	target_os := target_os_from_option_tokens(options)
	output_cross_c := target_os == 'cross'
	freestanding := '--freestanding' in options || '-freestanding' in options
		|| 'freestanding' in options
	validate_target_contract(target_os, freestanding)
	freestanding_hooks := freestanding_hooks_from_option_tokens(options)
	if freestanding_hooks.len > 0 && !freestanding {
		eprintln('error: freestanding hooks require freestanding target mode')
		exit(1)
	}
	mut user_defines := []string{}
	if output_cross_c {
		user_defines << 'cross'
	}
	if freestanding {
		user_defines << 'freestanding'
	}
	add_freestanding_hook_defines(mut user_defines, freestanding_hooks)

	implicit_skip_builtin := freestanding && freestanding_hooks.len == 0
	return Preferences{
		// config flags
		debug:                 '--debug' in options
		verbose:               '--verbose' in options || '-v' in options
		skip_genv:             '--skip-genv' in options
		skip_builtin:          '--skip-builtin' in options || implicit_skip_builtin
		skip_imports:          '--skip-imports' in options
		skip_type_check:       '--skip-type-check' in options
		no_parallel:           '-no-parallel' in options || '--no-parallel' in options
		no_parallel_transform: '-no-parallel' in options || '--no-parallel' in options
		no_cache:              '-nocache' in options || '--nocache' in options
		no_markused:           '-nomarkused' in options || '--nomarkused' in options
		show_cc:               '-showcc' in options || '--showcc' in options
		stats:                 '-stats' in options || '--stats' in options
		print_parsed_files:    '-print-parsed-files' in options || '--print-parsed-files' in options
		use_context_allocator: '--profile-alloc' in options || '-profile-alloc' in options
		is_shared_lib:         '-shared' in options || '--shared' in options
		no_optimize:           '-O0' in options || '-prod' !in options
		is_prod:               '-prod' in options
		prealloc:              '-prealloc' in options
		single_backend:        '--single-backend' in options || '-single-backend' in options
		backend:               backend
		arch:                  arch
		target_os:             target_os
		output_cross_c:        output_cross_c
		freestanding:          freestanding
		freestanding_hooks:    freestanding_hooks
		user_defines:          user_defines
		explicit_user_defines: []string{}
	}
}

// get_effective_arch returns the architecture to use based on preferences and OS
pub fn (p &Preferences) get_effective_arch() Arch {
	if p.arch != .auto {
		return p.arch
	}
	// Auto-detect: macOS defaults to arm64, others to x64
	return if normalize_current_os_name(p.target_os_or_host()) == 'macos' {
		Arch.arm64
	} else {
		Arch.x64
	}
}