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

import os
import v2.ast
import v2.parser
import v2.pref as vpref
import v2.token
import v2.transformer
import v2.types

fn build_ssa_for_runtime_symbol_test(code string) &Module {
    return build_ssa_for_runtime_symbol_target_test(code, 'linux')
}

fn build_ssa_for_runtime_symbol_target_test(code string, target_os string) &Module {
    tmp_file := os.join_path(os.vtmp_dir(), 'v2_ssa_runtime_symbols_${os.getpid()}.v')
    os.write_file(tmp_file, code) or { panic('failed to write temp file') }
    defer {
        os.rm(tmp_file) or {}
    }
    mut prefs := &vpref.Preferences{
        backend:     .x64
        no_parallel: true
    }
    prefs.target_os = target_os
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files([tmp_file], mut file_set)
    mut env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut trans := transformer.Transformer.new_with_pref(env, prefs)
    transformed := trans.transform_files(files)
    mut ssa_mod := Module.new('runtime_symbols')
    mut b := Builder.new_with_env(ssa_mod, env)
    b.target_os = target_os
    b.build_all(transformed)
    return ssa_mod
}

fn build_ssa_for_runtime_symbol_target_flat_test(code string, target_os string) &Module {
    tmp_file := os.join_path(os.vtmp_dir(), 'v2_ssa_runtime_symbols_flat_${os.getpid()}.v')
    os.write_file(tmp_file, code) or { panic('failed to write temp file') }
    defer {
        os.rm(tmp_file) or {}
    }
    mut prefs := &vpref.Preferences{
        backend:     .x64
        no_parallel: true
    }
    prefs.target_os = target_os
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(prefs)
    files := par.parse_files([tmp_file], mut file_set)
    mut env := types.Environment.new()
    mut checker := types.Checker.new(prefs, file_set, env)
    checker.check_files(files)
    mut trans := transformer.Transformer.new_with_pref(env, prefs)
    flat := ast.flatten_files(files)
    transformed_flat, _ := trans.transform_files_to_flat(&flat, files)
    mut ssa_mod := Module.new('runtime_symbols_flat')
    mut b := Builder.new_with_env(ssa_mod, env)
    b.target_os = target_os
    b.build_all_from_flat(&transformed_flat)
    return ssa_mod
}

fn stdio_loaded_external_symbol_names(m &Module) []string {
    mut names := []string{}
    for val in m.values {
        if val.kind != .instruction {
            continue
        }
        instr := m.instrs[val.index]
        if instr.op != .load || instr.operands.len != 1 {
            continue
        }
        operand := instr.operands[0]
        if operand <= 0 || operand >= m.values.len {
            continue
        }
        global := m.values[operand]
        if global.kind == .global
            && global.name in ['stdout', 'stderr', 'stdin', '__stdoutp', '__stderrp', '__stdinp'] {
            assert global.index >= 0 && global.index < m.globals.len
            assert m.globals[global.index].linkage == .external
            names << global.name
        }
    }
    return names
}

fn called_function_names(m &Module) []string {
    mut names := []string{}
    for val in m.values {
        if val.kind != .instruction {
            continue
        }
        instr := m.instrs[val.index]
        if instr.op != .call || instr.operands.len == 0 {
            continue
        }
        callee := instr.operands[0]
        if callee <= 0 || callee >= m.values.len {
            continue
        }
        callee_val := m.values[callee]
        if callee_val.kind == .func_ref {
            names << callee_val.name
        }
    }
    return names
}

fn global_value_names(m &Module) []string {
    return m.values.filter(it.kind == .global).map(it.name)
}

fn store_destination_call_names(m &Module) []string {
    mut names := []string{}
    for val in m.values {
        if val.kind != .instruction {
            continue
        }
        instr := m.instrs[val.index]
        if instr.op != .store || instr.operands.len < 2 {
            continue
        }
        dest := instr.operands[1]
        if dest <= 0 || dest >= m.values.len {
            continue
        }
        dest_val := m.values[dest]
        if dest_val.kind != .instruction {
            continue
        }
        dest_instr := m.instrs[dest_val.index]
        if dest_instr.op != .call || dest_instr.operands.len == 0 {
            continue
        }
        callee := dest_instr.operands[0]
        if callee <= 0 || callee >= m.values.len {
            continue
        }
        callee_val := m.values[callee]
        if callee_val.kind == .func_ref {
            names << callee_val.name
        }
    }
    return names
}

fn store_destination_global_names(m &Module) []string {
    mut names := []string{}
    for val in m.values {
        if val.kind != .instruction {
            continue
        }
        instr := m.instrs[val.index]
        if instr.op != .store || instr.operands.len < 2 {
            continue
        }
        dest := instr.operands[1]
        if dest <= 0 || dest >= m.values.len {
            continue
        }
        dest_val := m.values[dest]
        if dest_val.kind == .global {
            names << dest_val.name
        }
    }
    return names
}

fn c_errno_write_test_code() string {
    return '
module main

fn reset_errno() {
    C.errno = 0
}

fn bump_errno() {
    C.errno += 1
}

fn main() {
    reset_errno()
    bump_errno()
}
'
}

fn test_c_float_epsilon_macros_are_ssa_constants_not_external_globals() {
    m := build_ssa_for_runtime_symbol_test('
module main

fn seek_set() int {
    return C.SEEK_SET
}

fn flt_epsilon() f32 {
    return C.FLT_EPSILON
}

fn dbl_epsilon() f64 {
    return C.DBL_EPSILON
}

fn main() {
    _ := seek_set()
    _ := flt_epsilon()
    _ := dbl_epsilon()
}
')
    mut has_seek_set_const := false
    mut has_flt_epsilon_const := false
    mut has_dbl_epsilon_const := false
    for val in m.values {
        if val.kind == .global {
            assert val.name != 'SEEK_SET'
            assert val.name != 'FLT_EPSILON'
            assert val.name != 'DBL_EPSILON'
        }
        if val.kind != .constant {
            continue
        }
        if val.name == '1.19209290e-07' {
            typ := m.type_store.types[val.typ]
            assert typ.kind == .float_t
            assert typ.width == 32
            has_flt_epsilon_const = true
        }
        if val.name == '2.2204460492503131e-16' {
            typ := m.type_store.types[val.typ]
            assert typ.kind == .float_t
            assert typ.width == 64
            has_dbl_epsilon_const = true
        }
        if val.name == '0' {
            typ := m.type_store.types[val.typ]
            if typ.kind == .int_t && typ.width == 32 {
                has_seek_set_const = true
            }
        }
    }
    assert has_seek_set_const
    assert has_flt_epsilon_const
    assert has_dbl_epsilon_const
}

fn windows_std_handle_macros_code() string {
    return '
module main

fn input_handle() u32 {
    return C.STD_INPUT_HANDLE
}

fn output_handle() u32 {
    return C.STD_OUTPUT_HANDLE
}

fn error_handle() u32 {
    return C.STD_ERROR_HANDLE
}

fn main() {
    _ := input_handle()
    _ := output_handle()
    _ := error_handle()
}
'
}

fn windows_invalid_handle_value_macro_code() string {
    return '
module main

fn invalid_handle() voidptr {
    return C.INVALID_HANDLE_VALUE
}

fn main() {
    _ := invalid_handle()
}
'
}

fn assert_windows_std_handle_macros_are_ssa_constants_not_external_globals(m &Module) {
    global_names := global_value_names(m)
    expected_consts := {
        'STD_INPUT_HANDLE':  '4294967286'
        'STD_OUTPUT_HANDLE': '4294967285'
        'STD_ERROR_HANDLE':  '4294967284'
    }
    mut seen_consts := map[string]bool{}
    for name, const_name in expected_consts {
        assert name !in global_names
        seen_consts[const_name] = false
    }
    for val in m.values {
        if val.kind != .constant || val.name !in seen_consts {
            continue
        }
        typ := m.type_store.types[val.typ]
        assert typ.kind == .int_t
        assert typ.width == 32
        assert typ.is_unsigned
        seen_consts[val.name] = true
    }
    for _, const_name in expected_consts {
        assert seen_consts[const_name]
    }
}

fn test_windows_std_handle_macros_are_ssa_constants_not_external_globals() {
    m := build_ssa_for_runtime_symbol_target_test(windows_std_handle_macros_code(), 'windows')
    assert_windows_std_handle_macros_are_ssa_constants_not_external_globals(m)
}

fn test_windows_std_handle_macros_are_flat_ssa_constants_not_external_globals() {
    m := build_ssa_for_runtime_symbol_target_flat_test(windows_std_handle_macros_code(), 'windows')
    assert_windows_std_handle_macros_are_ssa_constants_not_external_globals(m)
}

fn assert_windows_invalid_handle_value_macro_is_pointer_sized_constant_not_external_global(m &Module) {
    global_names := global_value_names(m)
    assert 'INVALID_HANDLE_VALUE' !in global_names

    mut has_invalid_handle_const := false
    for val in m.values {
        if val.kind != .constant || val.name != '-1' {
            continue
        }
        typ := m.type_store.types[val.typ]
        if typ.kind == .ptr_t {
            has_invalid_handle_const = true
        }
    }
    assert has_invalid_handle_const
}

fn test_windows_invalid_handle_value_macro_is_pointer_sized_constant_not_external_global() {
    m := build_ssa_for_runtime_symbol_target_test(windows_invalid_handle_value_macro_code(),
        'windows')
    assert_windows_invalid_handle_value_macro_is_pointer_sized_constant_not_external_global(m)
}

fn test_windows_invalid_handle_value_macro_is_flat_pointer_sized_constant_not_external_global() {
    m := build_ssa_for_runtime_symbol_target_flat_test(windows_invalid_handle_value_macro_code(),
        'windows')
    assert_windows_invalid_handle_value_macro_is_pointer_sized_constant_not_external_global(m)
}

fn test_c_stdio_globals_are_loaded_on_non_macos_targets() {
    m := build_ssa_for_runtime_symbol_target_test('
module main

fn main() {
    _ := C.stdout
    _ := C.stderr
    _ := C.stdin
}
',
        'linux')
    load_names := stdio_loaded_external_symbol_names(m)
    global_names := global_value_names(m)

    assert 'stdout' in load_names
    assert 'stderr' in load_names
    assert 'stdin' in load_names
    assert '__stdoutp' !in load_names
    assert '__stderrp' !in load_names
    assert '__stdinp' !in load_names
    assert 'C.stdout' !in global_names
    assert 'C.stderr' !in global_names
    assert 'C.stdin' !in global_names
}

fn test_c_errno_uses_errno_location_on_linux_targets() {
    m := build_ssa_for_runtime_symbol_target_test('
module main

fn read_errno() int {
    return C.errno
}

fn main() {
    _ := read_errno()
}
',
        'linux')
    call_names := called_function_names(m)
    global_names := global_value_names(m)

    assert '__errno_location' in call_names
    assert '__error' !in call_names
    assert 'errno' !in global_names
}

fn test_c_errno_flat_reads_use_errno_location_on_linux_targets() {
    m := build_ssa_for_runtime_symbol_target_flat_test('
module main

fn read_errno() int {
    return C.errno
}

fn main() {
    _ := read_errno()
}
',
        'linux')
    call_names := called_function_names(m)
    global_names := global_value_names(m)

    assert '__errno_location' in call_names
    assert '__error' !in call_names
    assert 'errno' !in global_names
}

fn test_c_errno_writes_use_errno_location_on_linux_targets() {
    m := build_ssa_for_runtime_symbol_target_test(c_errno_write_test_code(), 'linux')
    call_names := called_function_names(m)
    store_call_names := store_destination_call_names(m)
    global_names := global_value_names(m)

    assert call_names.filter(it == '__errno_location').len == 2
    assert store_call_names.filter(it == '__errno_location').len == 2
    assert '__error' !in call_names
    assert 'errno' !in global_names
    assert 'C.errno' !in global_names
}

fn test_c_errno_flat_writes_use_errno_location_on_linux_targets() {
    m := build_ssa_for_runtime_symbol_target_flat_test(c_errno_write_test_code(), 'linux')
    call_names := called_function_names(m)
    store_call_names := store_destination_call_names(m)
    global_names := global_value_names(m)

    assert call_names.filter(it == '__errno_location').len == 2
    assert store_call_names.filter(it == '__errno_location').len == 2
    assert '__error' !in call_names
    assert 'errno' !in global_names
    assert 'C.errno' !in global_names
}

fn test_c_errno_uses_error_on_macos_targets() {
    m := build_ssa_for_runtime_symbol_target_test('
module main

fn read_errno() int {
    return C.errno
}

fn main() {
    _ := read_errno()
}
',
        'macos')
    call_names := called_function_names(m)
    global_names := global_value_names(m)

    assert '__error' in call_names
    assert '__errno_location' !in call_names
    assert 'errno' !in global_names
}

fn test_c_errno_writes_use_error_on_macos_targets() {
    m := build_ssa_for_runtime_symbol_target_test(c_errno_write_test_code(), 'macos')
    call_names := called_function_names(m)
    store_call_names := store_destination_call_names(m)
    global_names := global_value_names(m)

    assert call_names.filter(it == '__error').len == 2
    assert store_call_names.filter(it == '__error').len == 2
    assert '__errno_location' !in call_names
    assert 'errno' !in global_names
    assert 'C.errno' !in global_names
}

fn test_c_errno_flat_writes_use_error_on_macos_targets() {
    m := build_ssa_for_runtime_symbol_target_flat_test(c_errno_write_test_code(), 'macos')
    call_names := called_function_names(m)
    store_call_names := store_destination_call_names(m)
    global_names := global_value_names(m)

    assert call_names.filter(it == '__error').len == 2
    assert store_call_names.filter(it == '__error').len == 2
    assert '__errno_location' !in call_names
    assert 'errno' !in global_names
    assert 'C.errno' !in global_names
}

fn test_c_errno_uses_errno_on_windows_targets() {
    m := build_ssa_for_runtime_symbol_target_test('
module main

fn read_errno() int {
    return C.errno
}

fn main() {
    _ := read_errno()
}
',
        'windows')
    call_names := called_function_names(m)
    global_names := global_value_names(m)

    assert '_errno' in call_names
    assert '__errno_location' !in call_names
    assert '__error' !in call_names
    assert 'errno' !in global_names
    assert 'C.errno' !in global_names
}

fn test_c_errno_writes_use_errno_on_windows_targets() {
    m := build_ssa_for_runtime_symbol_target_test(c_errno_write_test_code(), 'windows')
    call_names := called_function_names(m)
    store_call_names := store_destination_call_names(m)
    store_global_names := store_destination_global_names(m)
    global_names := global_value_names(m)

    assert call_names.filter(it == '_errno').len == 2
    assert store_call_names.filter(it == '_errno').len == 2
    assert '__errno_location' !in call_names
    assert '__error' !in call_names
    assert store_global_names.filter(it == 'errno').len == 0
    assert 'errno' !in global_names
    assert 'C.errno' !in global_names
}

fn test_c_errno_flat_writes_use_errno_on_windows_targets() {
    m := build_ssa_for_runtime_symbol_target_flat_test(c_errno_write_test_code(), 'windows')
    call_names := called_function_names(m)
    store_call_names := store_destination_call_names(m)
    store_global_names := store_destination_global_names(m)
    global_names := global_value_names(m)

    assert call_names.filter(it == '_errno').len == 2
    assert store_call_names.filter(it == '_errno').len == 2
    assert '__errno_location' !in call_names
    assert '__error' !in call_names
    assert store_global_names.filter(it == 'errno').len == 0
    assert 'errno' !in global_names
    assert 'C.errno' !in global_names
}

fn test_c_stdio_globals_are_loaded_on_windows_targets() {
    m := build_ssa_for_runtime_symbol_target_test('
module main

fn main() {
    _ := C.stdout
    _ := C.stderr
    _ := C.stdin
}
',
        'windows')
    load_names := stdio_loaded_external_symbol_names(m)
    global_names := global_value_names(m)

    assert 'stdout' in load_names
    assert 'stderr' in load_names
    assert 'stdin' in load_names
    assert '__stdoutp' !in load_names
    assert '__stderrp' !in load_names
    assert '__stdinp' !in load_names
    assert 'C.stdout' !in global_names
    assert 'C.stderr' !in global_names
    assert 'C.stdin' !in global_names
}

fn test_c_stdio_globals_are_loaded_from_macos_symbols_on_macos_targets() {
    m := build_ssa_for_runtime_symbol_target_test('
module main

fn main() {
    _ := C.stdout
    _ := C.stderr
    _ := C.stdin
}
',
        'macos')
    load_names := stdio_loaded_external_symbol_names(m)
    global_names := global_value_names(m)

    assert '__stdoutp' in load_names
    assert '__stderrp' in load_names
    assert '__stdinp' in load_names
    assert 'stdout' !in load_names
    assert 'stderr' !in load_names
    assert 'stdin' !in load_names
    assert 'C.stdout' !in global_names
    assert 'C.stderr' !in global_names
    assert 'C.stdin' !in global_names
}