import os

const comptime_decl_vexe = @VEXE
const comptime_decl_tests_dir = os.dir(@FILE)
const comptime_decl_v3_dir = os.dir(comptime_decl_tests_dir)
const comptime_decl_vlib_dir = os.dir(comptime_decl_v3_dir)
const comptime_decl_v3_src = os.join_path(comptime_decl_v3_dir, 'v3.v')

fn comptime_decl_build_v3() string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_comptime_top_level_decl_test')
    build :=
        os.execute('${comptime_decl_vexe} -gc none -path "${comptime_decl_vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${comptime_decl_v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

fn comptime_decl_count(c_code string, needle string) int {
    mut count := 0
    mut rest := c_code
    for {
        idx := rest.index(needle) or { break }
        count++
        rest = rest[idx + needle.len..]
    }
    return count
}

fn comptime_decl_struct_body(c_code string, name string) string {
    start := c_code.index('struct ${name} {') or { return '' }
    rest := c_code[start..]
    end := rest.index('\n};') or { return rest }
    return rest[..end]
}

fn comptime_decl_gen_c(v3_bin string, name string, feature bool) string {
    root := os.join_path(os.temp_dir(), 'v3_comptime_top_level_decl_${name}_${os.getpid()}')
    os.rmdir_all(root) or {}
    os.mkdir_all(root) or { panic(err) }
    main_path := os.join_path(root, 'main.v')
    os.write_file(main_path, "module main

$if some_feature ? {
    struct Choice {
        x int
    }
} $else {
    struct Choice {}
}

struct Holder {
    choice Choice
}

fn main() {
    $if some_feature ? {
        holder := Holder{
            choice: Choice{
                x: 1
            }
        }
        println(int_str(holder.choice.x))
    } $else {
        holder := Holder{
            choice: Choice{}
        }
        _ = holder
        println('dummy')
    }
}
") or {
        panic(err)
    }
    bin_path := os.join_path(root, 'out')
    feature_arg := if feature { '-d some_feature' } else { '' }
    compile := os.execute('${v3_bin} ${main_path} ${feature_arg} -b c -o ${bin_path}')
    assert compile.exit_code == 0, '${name}: compile failed: ${compile.output}'
    c_path := bin_path + '.c'
    assert os.exists(c_path), '${name}: missing generated C ${c_path}'
    return os.read_file(c_path) or { panic(err) }
}

fn comptime_decl_gen_c_source(v3_bin string, name string, source string, flags string) string {
    root := os.join_path(os.temp_dir(), 'v3_comptime_top_level_decl_${name}_${os.getpid()}')
    os.rmdir_all(root) or {}
    os.mkdir_all(root) or { panic(err) }
    main_path := os.join_path(root, 'main.v')
    os.write_file(main_path, source) or { panic(err) }
    c_path := os.join_path(root, 'out.c')
    compile := os.execute('${v3_bin} ${main_path} ${flags} -b c -o ${c_path}')
    assert compile.exit_code == 0, '${name}: C output failed: ${compile.output}'
    assert os.exists(c_path), '${name}: missing generated C ${c_path}'
    return os.read_file(c_path) or { panic(err) }
}

fn comptime_decl_compile_run_source(v3_bin string, name string, source string, flags string) os.Result {
    root := os.join_path(os.temp_dir(), 'v3_comptime_top_level_decl_run_${name}_${os.getpid()}')
    os.rmdir_all(root) or {}
    os.mkdir_all(root) or { panic(err) }
    main_path := os.join_path(root, 'main.v')
    os.write_file(main_path, source) or { panic(err) }
    bin_path := os.join_path(root, 'out')
    compile := os.execute('${v3_bin} ${main_path} ${flags} -o ${bin_path}')
    assert compile.exit_code == 0, '${name}: compile failed: ${compile.output}'
    return os.execute(bin_path)
}

fn test_top_level_decls_inside_active_comptime_branch_are_codegen_visible() {
    v3_bin := comptime_decl_build_v3()
    else_c := comptime_decl_gen_c(v3_bin, 'else_branch', false)
    else_choice := comptime_decl_struct_body(else_c, 'Choice')
    assert comptime_decl_count(else_c, 'struct Choice {') == 1, else_c
    assert else_choice.contains('_dummy'), else_c
    assert !else_choice.contains('int x;'), else_c

    feature_c := comptime_decl_gen_c(v3_bin, 'feature_branch', true)
    feature_choice := comptime_decl_struct_body(feature_c, 'Choice')
    assert comptime_decl_count(feature_c, 'struct Choice {') == 1, feature_c
    assert feature_choice.contains('int x;'), feature_c
    assert !feature_choice.contains('_dummy'), feature_c
}

fn test_declaration_only_top_level_comptime_block_does_not_synthesize_main() {
    v3_bin := comptime_decl_build_v3()
    c_code := comptime_decl_gen_c_source(v3_bin, 'decl_only_no_main', 'module main

$if some_feature ? {
    fn helper() int {
        return 3
    }
} $else {
    struct Helper {}
}
',
        '-d some_feature')
    assert !c_code.contains('int main('), c_code
}

fn test_top_level_comptime_block_with_statement_still_synthesizes_main() {
    v3_bin := comptime_decl_build_v3()
    c_code := comptime_decl_gen_c_source(v3_bin, 'stmt_synth_main', "module main

$if some_feature ? {
    println('active')
} $else {
    fn helper() int {
        return 3
    }
}
",
        '-d some_feature')
    assert c_code.contains('int main('), c_code
    assert c_code.contains('active'), c_code
}

fn test_synthetic_top_level_block_keeps_main_scope_locals() {
    v3_bin := comptime_decl_build_v3()
    run := comptime_decl_compile_run_source(v3_bin, 'synthetic_block_main_scope', 'module main

$if some_feature ? {
    x := 1
    y := 2
}

fn helper() int {
    return 0
}

println(int_str(x + y))
',
        '-d some_feature')
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == '3'
}