module x64

import os
import v2.mir

struct X64BackendCompileFailure {
    stdout    string
    stderr    string
    exit_code int
}

fn run_x64_backend_compile_failure(name string, source string) X64BackendCompileFailure {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v_x64_backend_diagnostics_${name}_${os.getpid()}')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    source_path := os.join_path(tmp_dir, '${name}.v')
    bin_path := os.join_path(tmp_dir, name)
    os.write_file(source_path, source) or { panic(err) }
    vexe := x64_backend_diagnostic_vexe_command_path()
    mut build := os.new_process(vexe)
    defer {
        build.close()
    }
    build.set_args(['-v2', '-b', 'x64', source_path, '-o', bin_path])
    build.set_redirect_stdio()
    build.run()
    build.wait()
    stdout := x64_backend_diagnostic_stdout(build.stdout_slurp())
    stderr := build.stderr_slurp()
    return X64BackendCompileFailure{
        stdout:    stdout
        stderr:    stderr
        exit_code: build.code
    }
}

fn x64_backend_diagnostic_vexe_command_path() string {
    vexe := os.getenv_opt('VEXE') or { @VEXE }
    if os.is_abs_path(vexe) || !os.exists(vexe) {
        return vexe
    }
    return os.abs_path(vexe)
}

fn x64_backend_diagnostic_stdout(stdout string) string {
    mut lines := []string{}
    for line in stdout.split_into_lines() {
        if line.starts_with(' * ') {
            continue
        }
        lines << line
    }
    return lines.join('\n')
}

fn assert_x64_user_visible_compile_failure(failure X64BackendCompileFailure, expected_message string) {
    assert failure.exit_code != 0, failure.stdout + failure.stderr
    assert failure.stdout == '', failure.stdout
    assert failure.stderr.contains(expected_message), failure.stderr
    assert failure.stderr.contains(x64_backend_limitation_hint), failure.stderr
    assert !failure.stderr.contains('Link failed:'), failure.stderr
    assert !failure.stderr.contains('V panic:'), failure.stderr
    assert !failure.stderr.contains('Backtrace'), failure.stderr
    assert_x64_message_avoids_old_wording(failure.stderr)
}

fn assert_x64_clean_user_diagnostic_message(msg string) {
    assert msg.starts_with('x64: unsupported backend feature: '), msg
    assert !msg.contains('Link failed:'), msg
    assert !msg.contains('V panic:'), msg
    assert !msg.contains('Backtrace'), msg
    assert_x64_message_avoids_old_wording(msg)
}

fn assert_x64_message_avoids_old_wording(msg string) {
    assert !msg.contains('reachable helper'), msg
    assert !msg.contains('stdout/stderr path'), msg
    assert !msg.contains('must be compiled'), msg
    assert !msg.contains('lowered before linking'), msg
    assert !msg.contains('before external linking'), msg
    assert !msg.contains('cannot resolve C stdio symbol'), msg
    assert !msg.contains('C FILE streams'), msg
}

fn assert_x64_message_mentions_only_target_linker(format ObjectFormat, msg string) {
    match format {
        .elf {
            assert msg.contains('ELF linker'), msg
            assert !msg.contains('Mach-O'), msg
            assert !msg.contains('PE linker'), msg
            assert !msg.contains('Windows'), msg
            assert !msg.contains('Kernel32'), msg
            assert !msg.contains('macOS'), msg
        }
        .macho {
            assert msg.contains('Mach-O linker'), msg
            assert !msg.contains('ELF linker'), msg
            assert !msg.contains('PE linker'), msg
            assert !msg.contains('Windows'), msg
            assert !msg.contains('Kernel32'), msg
            assert !msg.contains('Linux'), msg
        }
        .coff {
            assert msg.contains('PE linker'), msg
            assert !msg.contains('ELF linker'), msg
            assert !msg.contains('Mach-O'), msg
            assert !msg.contains('Linux'), msg
            assert !msg.contains('macOS'), msg
        }
    }
}

fn test_x64_user_visible_stderr_reports_clean_codegen_abi_unsupported_without_link_noise() {
    $if windows {
        println('skipping ${@FN}: SysV codegen diagnostic is not available on Windows')
    } $else $if x64 {
        failure := run_x64_backend_compile_failure('clean_codegen_abi_unsupported', 'module main

fn many(a0 f64, a1 f64, a2 f64, a3 f64, a4 f64, a5 f64, a6 f64, a7 f64, a8 f64) f64 {
    return a8
}

fn main() {
    _ = many(1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0)
}
')
        assert_x64_user_visible_compile_failure(failure,
            'x64: unsupported backend feature: stack-passed float parameter')
        assert !failure.stderr.contains('Windows'), failure.stderr
        assert !failure.stderr.contains('Kernel32'), failure.stderr
        assert !failure.stderr.contains('Mach-O'), failure.stderr
        assert !failure.stderr.contains('PE linker'), failure.stderr
    }
}

fn test_x64_user_visible_stderr_reports_captured_fn_literal_unsupported() {
    $if x64 {
        failure := run_x64_backend_compile_failure('captured_fn_literal_unsupported', 'module main

fn make_delta(delta int) fn (int) int {
    return fn [delta] (value int) int {
        return value + delta
    }
}

fn main() {
    f := make_delta(10)
    println(f(1))
}
')
        assert_x64_user_visible_compile_failure(failure, 'x64: unsupported backend feature: ')
        assert failure.stderr.contains('native x64 cannot lower captured function literal'), failure.stderr

        assert failure.stderr.contains('closure environments are not implemented yet'), failure.stderr
    }
}

fn test_x64_unsupported_backend_feature_message_is_normalized() {
    assert x64_unsupported_backend_feature_message('stack-passed float parameter') == 'x64: unsupported backend feature: stack-passed float parameter'
    assert x64_unsupported_backend_feature_message('backend feature: Windows argument lowering') == 'x64: unsupported backend feature: Windows argument lowering'
    assert x64_unsupported_backend_feature_message('backend feature: SysV direct aggregate call result with MEMORY eightbyte classes is not implemented yet') == 'x64: unsupported backend feature: SysV direct aggregate call result with MEMORY eightbyte classes is not implemented yet'
}

fn test_x64_user_visible_linker_diagnostic_message_for_generic_external_by_format() {
    for format in [ObjectFormat.elf, .macho, .coff] {
        msg := x64_unresolved_external_symbol_message(format, 'v_missing_runtime_symbol',
            'referenced from test relocation')

        assert_x64_clean_user_diagnostic_message(msg)
        assert_x64_message_mentions_only_target_linker(format, msg)
        assert msg.contains('cannot resolve external symbol `v_missing_runtime_symbol` yet'), msg
        assert msg.contains('referenced from test relocation'), msg
        assert !msg.contains('C stdio/file-descriptor symbol'), msg
        assert !msg.contains('Windows'), msg
        assert !msg.contains('Kernel32'), msg
        assert !msg.contains('C FILE/stdio'), msg
    }
}

fn test_x64_user_visible_crt_stdio_and_fd_diagnostic_is_windows_only() {
    for symbol_name in ['stderr', 'fread', '_get_osfhandle', '_open_osfhandle'] {
        for format in [ObjectFormat.elf, .macho] {
            msg := x64_unresolved_external_symbol_message(format, symbol_name,
                'referenced from test relocation')

            assert_x64_clean_user_diagnostic_message(msg)
            assert_x64_message_mentions_only_target_linker(format, msg)
            assert msg.contains('cannot resolve external symbol `${symbol_name}` yet'), msg
            assert !msg.contains('C stdio/file-descriptor symbol'), msg
            assert !msg.contains('Kernel32'), msg
            assert !msg.contains('C FILE/stdio'), msg
        }

        pe_msg := x64_unresolved_external_symbol_message(.coff, symbol_name,
            'referenced from test relocation')
        assert_x64_clean_user_diagnostic_message(pe_msg)
        assert_x64_message_mentions_only_target_linker(.coff, pe_msg)
        assert pe_msg.contains('cannot resolve C stdio/file-descriptor symbol `${symbol_name}`'), pe_msg
        assert pe_msg.contains('Windows x64 native backend uses Kernel32 handles'), pe_msg
        assert pe_msg.contains('Kernel32 handles'), pe_msg
        assert pe_msg.contains('C FILE/stdio calls'), pe_msg
        assert !pe_msg.contains('Linux'), pe_msg
        assert !pe_msg.contains('macOS'), pe_msg
    }
}

fn test_x64_user_visible_linker_diagnostic_message_for_missing_runtime_helper_by_format() {
    for format in [ObjectFormat.elf, .macho, .coff] {
        msg := x64_unresolved_external_symbol_message(format, 'builtin__Map_string_int__keys',
            'referenced from test relocation')

        assert_x64_clean_user_diagnostic_message(msg)
        assert_x64_message_mentions_only_target_linker(format, msg)
        assert msg.contains('cannot resolve V runtime helper `builtin__Map_string_int__keys`'), msg
        assert msg.contains('native x64 backend does not implement this feature for this target yet'), msg
        assert msg.contains('referenced from test relocation'), msg
        assert !msg.contains('C stdio/file-descriptor symbol'), msg
        assert !msg.contains('Kernel32'), msg
        assert !msg.contains('C FILE/stdio'), msg
        assert !msg.contains('not imported'), msg
    }
}

fn test_x64_gen_detects_missing_runtime_helper_while_preparing_output() {
    for format in [ObjectFormat.elf, .macho, .coff] {
        mut mod := mir.Module{}
        mut gen := Gen.new_with_format(&mod, format)
        match format {
            .elf {
                gen.elf.add_undefined('builtin__Map_string_int__keys')
            }
            .macho {
                gen.macho.add_undefined('_builtin__Map_string_int__keys')
            }
            .coff {
                gen.coff.add_undefined('builtin__Map_string_int__keys')
            }
        }

        msg := gen.unsupported_external_symbol_message() or {
            assert false
            continue
        }
        assert_x64_clean_user_diagnostic_message(msg)
        assert_x64_message_mentions_only_target_linker(format, msg)
        assert msg.contains(x64_linker_name(format)), msg
        assert msg.contains('builtin__Map_string_int__keys'), msg
        assert msg.contains('cannot resolve V runtime helper `builtin__Map_string_int__keys`'), msg
        assert msg.contains('native x64 backend does not implement this feature for this target yet'), msg
        assert msg.contains('needed while preparing native x64 output'), msg
    }
}

fn test_x64_gen_keeps_linker_resolved_external_symbols_for_external_linkers() {
    for format in [ObjectFormat.elf, .macho, .coff] {
        mut mod := mir.Module{}
        mut gen := Gen.new_with_format(&mod, format)
        match format {
            .elf {
                gen.elf.add_undefined('calloc')
            }
            .macho {
                gen.macho.add_undefined('_calloc')
            }
            .coff {
                gen.coff.add_undefined('calloc')
            }
        }

        if msg := gen.unsupported_external_symbol_message() {
            assert false, msg
        }
    }
}