import os

const vexe = @VEXE
const tests_dir = os.dir(@FILE)
const v3_dir = os.dir(tests_dir)
const v3_src = os.join_path(v3_dir, 'v3.v')
const hello_src = os.join_path(tests_dir, 'hello.v')

// test_prod_flag_before_input_uses_optimized_c_compile validates this v3 regression case.
fn test_prod_flag_before_input_uses_optimized_c_compile() {
    v3_bin := os.join_path(os.temp_dir(), 'v3_prod_flag_test')
    build := os.execute('${vexe} -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output

    out_bin := os.join_path(os.temp_dir(), 'v3_prod_hello')
    compile := os.execute('${v3_bin} -prod ${hello_src} -o ${out_bin}')
    assert compile.exit_code == 0, compile.output
    assert compile.output.contains('cc -std=gnu11 -O2')
    assert !compile.output.contains('tcc.exe')

    run := os.execute(out_bin)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == 'hello world'
}

// test_c99_flag_uses_c99_c_compile_mode validates this v3 regression case.
fn test_c99_flag_uses_c99_c_compile_mode() {
    v3_bin := os.join_path(os.temp_dir(), 'v3_c99_flag_test')
    build := os.execute('${vexe} -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output

    out_bin := os.join_path(os.temp_dir(), 'v3_c99_hello')
    compile := os.execute('${v3_bin} -prod -c99 ${hello_src} -o ${out_bin}')
    assert compile.exit_code == 0, compile.output
    assert compile.output.contains('cc -std=c99 -O2')
    assert !compile.output.contains('cc -std=gnu11')
    assert !compile.output.contains('tcc.exe')

    run := os.execute(out_bin)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == 'hello world'
}

// test_c99_flag_emits_linux_feature_macros_before_includes validates this v3 regression case.
fn test_c99_flag_emits_linux_feature_macros_before_includes() {
    v3_bin := os.join_path(os.temp_dir(), 'v3_c99_feature_macro_test')
    build := os.execute('${vexe} -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output

    out_c := os.join_path(os.temp_dir(), 'v3_c99_feature_macro_hello.c')
    compile := os.execute('${v3_bin} -c99 ${hello_src} -o ${out_c}')
    assert compile.exit_code == 0, compile.output

    c_code := os.read_file(out_c) or { panic(err) }
    gnu_idx := c_code.index('#define _GNU_SOURCE') or { -1 }
    posix_idx := c_code.index('#define _POSIX_C_SOURCE 200809L') or { -1 }
    include_idx := c_code.index('#include <stdio.h>') or { -1 }
    assert gnu_idx >= 0, c_code[..200]
    assert posix_idx >= 0, c_code[..200]
    assert include_idx >= 0, c_code[..200]
    assert gnu_idx < include_idx, c_code[..200]
    assert posix_idx < include_idx, c_code[..200]
}

// test_c99_flag_preserves_stdatomic_header validates this v3 regression case.
fn test_c99_flag_preserves_stdatomic_header() {
    v3_bin := os.join_path(os.temp_dir(), 'v3_c99_stdatomic_test')
    build := os.execute('${vexe} -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output

    src := os.join_path(os.temp_dir(), 'v3_c99_stdatomic_swap.v')
    os.write_file(src,
        "import sync.stdatomic\n\nfn main() {\n\tmut x := u64(1)\n\told := C.atomic_exchange_u64(voidptr(&x), u64(7))\n\tassert old == u64(1)\n\tassert x == u64(7)\n\tprintln('atomic exchange ok')\n}\n") or {
        panic(err)
    }

    out_bin := os.join_path(os.temp_dir(), 'v3_c99_stdatomic_swap')
    compile := os.execute('${v3_bin} -c99 ${src} -o ${out_bin}')
    assert compile.exit_code == 0, compile.output
    assert !compile.output.contains('C compilation failed'), compile.output

    run := os.execute(out_bin)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == 'atomic exchange ok'
}

// test_c99_flag_system_stdatomic_include_suppresses_fallback_typedef validates this v3 regression case.
fn test_c99_flag_system_stdatomic_include_suppresses_fallback_typedef() {
    v3_bin := os.join_path(os.temp_dir(), 'v3_c99_system_stdatomic_test')
    build := os.execute('${vexe} -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output

    src := os.join_path(os.temp_dir(), 'v3_c99_system_stdatomic.v')
    os.write_file(src,
        "#include <stdatomic.h>\n\nfn main() {\n\tprintln('system stdatomic ok')\n}\n") or {
        panic(err)
    }

    out_c := os.join_path(os.temp_dir(), 'v3_c99_system_stdatomic.c')
    gen_c := os.execute('${v3_bin} -c99 ${src} -o ${out_c}')
    assert gen_c.exit_code == 0, gen_c.output
    c_code := os.read_file(out_c) or { panic(err) }
    assert c_code.contains('#include <stdatomic.h>'), c_code
    assert !c_code.contains('typedef volatile uintptr_t atomic_uintptr_t;'), c_code
    assert c_code.contains('static inline u64 atomic_fetch_add_u64'), c_code

    out_bin := os.join_path(os.temp_dir(), 'v3_c99_system_stdatomic')
    compile := os.execute('${v3_bin} -prod -c99 ${src} -o ${out_bin}')
    assert compile.exit_code == 0, compile.output

    run := os.execute(out_bin)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == 'system stdatomic ok'

    gnu_bin := os.join_path(os.temp_dir(), 'v3_gnu11_system_stdatomic')
    gnu_compile := os.execute('${v3_bin} -prod ${src} -o ${gnu_bin}')
    assert gnu_compile.exit_code == 0, gnu_compile.output

    gnu_run := os.execute(gnu_bin)
    assert gnu_run.exit_code == 0, gnu_run.output
    assert gnu_run.output.trim_space() == 'system stdatomic ok'
}