// Copyright (c) 2026 Alexander Medvednikov. 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

fn is_target_or_mode_comptime_flag(name string) bool {
    return name in [
        'macos',
        'darwin',
        'mac',
        'linux',
        'windows',
        'bsd',
        'freebsd',
        'openbsd',
        'netbsd',
        'dragonfly',
        'android',
        'termux',
        'ios',
        'solaris',
        'qnx',
        'serenity',
        'plan9',
        'vinix',
        'cross',
        'none',
        'freestanding',
        'bare',
    ]
}

pub fn define_list_contains(defines []string, name string) bool {
    lower_name := name.to_lower()
    return name in defines || lower_name in defines
}

// pkgconfig_result runs pkg-config with `args` and returns stdout on success.
pub fn pkgconfig_result(args []string) ?string {
    if args.len == 0 {
        return none
    }
    mut quoted_args := []string{cap: args.len}
    for arg in args {
        quoted_args << os.quoted_path(arg)
    }
    result := os.execute('pkg-config ${quoted_args.join(' ')}')
    if result.exit_code != 0 {
        return none
    }
    return result.output.trim_space()
}

// comptime_pkgconfig_value evaluates `$pkgconfig('name')` in compile-time
// conditions. Missing pkg-config packages are false, matching v1 behavior.
pub fn comptime_pkgconfig_value(name string) bool {
    if _ := pkgconfig_result(['--exists', name]) {
        return true
    }
    return false
}

// comptime_flag_value evaluates a plain comptime flag identifier, as it would
// appear in `$if name {` or `@[if name]`. Use comptime_optional_flag_value for
// the optional `name ?` form. Shared between the parser (struct field
// conditionals) and the transformer (statement / expression $if).
//
// `pref` may be `nil` for early uses (some tests construct partial state);
// flags that depend on backend / user_defines then evaluate to `false`.
pub fn comptime_flag_value(pref &Preferences, name string) bool {
    match name {
        'macos', 'darwin', 'mac' {
            return pref.normalized_target_os() == 'macos'
        }
        'linux' {
            return pref.normalized_target_os() == 'linux'
        }
        'windows' {
            return pref.normalized_target_os() == 'windows'
        }
        'bsd' {
            return pref.normalized_target_os() in [
                'macos',
                'freebsd',
                'openbsd',
                'netbsd',
                'dragonfly',
            ]
        }
        'freebsd' {
            return pref.normalized_target_os() == 'freebsd'
        }
        'openbsd' {
            return pref.normalized_target_os() == 'openbsd'
        }
        'netbsd' {
            return pref.normalized_target_os() == 'netbsd'
        }
        'dragonfly' {
            return pref.normalized_target_os() == 'dragonfly'
        }
        'android' {
            return pref.normalized_target_os() == 'android'
        }
        'termux' {
            return pref.normalized_target_os() == 'termux'
        }
        'ios' {
            return pref.normalized_target_os() == 'ios'
        }
        'solaris' {
            return pref.normalized_target_os() == 'solaris'
        }
        'qnx' {
            return pref.normalized_target_os() == 'qnx'
        }
        'serenity' {
            return pref.normalized_target_os() == 'serenity'
        }
        'plan9' {
            return pref.normalized_target_os() == 'plan9'
        }
        'vinix' {
            return pref.normalized_target_os() == 'vinix'
        }
        'x64', '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 pref != unsafe { nil } && (pref.backend == .arm64 || pref.backend == .x64)
        }
        'v2_native_windows_pe_minimal' {
            return pref != unsafe { nil } && pref.backend == .x64
                && pref.get_effective_arch() == .x64 && pref.normalized_target_os() == 'windows'
        }
        // Native backend cannot resolve C.stdout/C.stderr data symbols through GOT,
        // so use C.write() instead of fwrite() for I/O operations.
        'builtin_write_buf_to_fd_should_use_c_write' {
            return pref != unsafe { nil } && (pref.backend == .arm64 || pref.backend == .x64)
        }
        'tinyc' {
            // For native backends, inline assembly from V source is not supported
            // by the SSA builder. Pretend we're TinyCC so that `$if arm64 && !tinyc`
            // guards select the software fallback path instead of inline asm.
            return pref != unsafe { nil } && (pref.backend == .arm64 || pref.backend == .x64)
        }
        'no_backtrace' {
            return pref != unsafe { nil } && ((pref.backend == .arm64 || pref.backend == .x64)
                || name in pref.user_defines)
        }
        'prealloc' {
            return pref != unsafe { nil } && pref.prealloc
        }
        'cross' {
            return pref != unsafe { nil } && (pref.is_cross_target() || name in pref.user_defines)
        }
        'none' {
            return pref != unsafe { nil } && pref.normalized_target_os() == 'none'
        }
        'freestanding' {
            return pref != unsafe { nil } && (pref.is_freestanding() || name in pref.user_defines)
        }
        'freestanding_hooks' {
            return pref != unsafe { nil }
                && (pref.has_freestanding_hooks() || name in pref.user_defines)
        }
        'freestanding_output' {
            return pref != unsafe { nil }
                && (pref.has_freestanding_hook('output') || name in pref.user_defines)
        }
        'freestanding_panic' {
            return pref != unsafe { nil }
                && (pref.has_freestanding_hook('panic') || name in pref.user_defines)
        }
        'freestanding_alloc' {
            return pref != unsafe { nil }
                && (pref.has_freestanding_hook('alloc') || name in pref.user_defines)
        }
        'new_int', 'gcboehm', 'autofree', 'ppc64' {
            return false
        }
        else {
            if pref != unsafe { nil } && define_list_contains(pref.user_defines, name) {
                return true
            }
            return false
        }
    }
}

pub fn comptime_optional_define_value(name string, user_defines []string, explicit_user_defines []string) bool {
    if define_list_contains(explicit_user_defines, name) {
        return true
    }
    if is_target_or_mode_comptime_flag(name.to_lower()) {
        return false
    }
    return define_list_contains(user_defines, name)
}

// comptime_optional_flag_value evaluates the `name ?` form. Unlike a plain
// `$if name`, target OS and target-mode flags must not become true implicitly.
// Non-target compiler capability flags keep their normal value, because V's
// builtin/runtime code uses the optional form for guarded internal fallbacks.
pub fn comptime_optional_flag_value(pref &Preferences, name string) bool {
    if pref == unsafe { nil } {
        return false
    }
    if comptime_optional_define_value(name, pref.user_defines, pref.explicit_user_defines) {
        return true
    }
    if is_target_or_mode_comptime_flag(name.to_lower()) {
        return false
    }
    return comptime_flag_value(pref, name)
}