import os

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

fn build_v3() string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_fn_nil_context_test')
    build :=
        os.execute('${vexe} -gc none -path "${vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

fn run_good(v3_bin string, name string, src string) string {
    good_src := os.join_path(os.temp_dir(), 'v3_${name}.v')
    os.write_file(good_src, src) or { panic(err) }
    good_bin := os.join_path(os.temp_dir(), 'v3_${name}')
    compile := os.execute('${v3_bin} ${good_src} -b c -o ${good_bin}')
    assert compile.exit_code == 0, '${name}: compile failed: ${compile.output}'
    assert !compile.output.contains('C compilation failed'), '${name}: C compilation failed: ${compile.output}'
    run := os.execute(good_bin)
    assert run.exit_code == 0, '${name}: run failed: ${run.output}'
    return run.output.trim_space()
}

fn run_bad(v3_bin string, name string, src string, expected string) {
    bad_src := os.join_path(os.temp_dir(), 'v3_${name}.v')
    os.write_file(bad_src, src) or { panic(err) }
    bad_bin := os.join_path(os.temp_dir(), 'v3_${name}')
    result := os.execute('${v3_bin} ${bad_src} -b c -o ${bad_bin}')
    assert result.exit_code != 0
    assert result.output.contains(expected), '${name}: missing `${expected}` in ${result.output}'
    assert !result.output.contains('C compilation failed')
}

fn test_unsafe_nil_contextually_matches_fn_fields() {
    v3_bin := build_v3()
    default_out := run_good(v3_bin, 'fn_nil_default', 'struct S {
    f fn (int) ! = unsafe { nil }
}

fn main() {
    _ := S{}
    println(int_str(1))
}
')
    assert default_out == '1'
    alias_out := run_good(v3_bin, 'fn_alias_nil_field_init', 'type Callback = fn (data voidptr)

struct S {
    f Callback
}

fn main() {
    _ := S{
        f: unsafe { nil }
    }
    println(int_str(2))
}
')
    assert alias_out == '2'
    run_bad(v3_bin, 'fn_field_rejects_voidptr_variable', 'struct S {
    f fn (int) !
}

fn main() {
    v := unsafe { nil }
    _ := S{
        f: v
    }
}
',
        'cannot initialize field `f` with `&void`; expected `fn(int) !void`')
    run_bad(v3_bin, 'fn_field_rejects_non_nil_unsafe_pointer', 'struct S {
    f fn (int) !
}

fn main() {
    _ := S{
        f: unsafe { &int(0) }
    }
}
',
        'cannot initialize field `f` with `&int`; expected `fn(int) !void`')
    run_bad(v3_bin, 'fn_field_rejects_voidptr_zero', 'struct S {
    f fn (int) !
}

fn main() {
    _ := S{
        f: voidptr(0)
    }
}
',
        'cannot initialize field `f` with `&void`; expected `fn(int) !void`')
    run_bad(v3_bin, 'fn_field_rejects_integer_zero', 'struct S {
    f fn (int) !
}

fn main() {
    _ := S{
        f: 0
    }
}
',
        'cannot initialize field `f` with `int`; expected `fn(int) !void`')
    run_bad(v3_bin, 'fn_field_rejects_wrong_arity', 'fn no_args() ! {
    return
}

struct S {
    f fn (int) !
}

fn main() {
    _ := S{
        f: no_args
    }
}
',
        'cannot initialize field `f` with `fn() !void`; expected `fn(int) !void`')
    run_bad(v3_bin, 'fn_field_rejects_wrong_return', 'fn returns_int(i int) !int {
    return i
}

struct S {
    f fn (int) !
}

fn main() {
    _ := S{
        f: returns_int
    }
}
',
        'cannot initialize field `f` with `fn(int) !int`; expected `fn(int) !void`')
    run_bad(v3_bin, 'fn_alias_field_rejects_wrong_arity', 'type Callback = fn (int) !

fn no_args() ! {
    return
}

struct S {
    f Callback
}

fn main() {
    _ := S{
        f: no_args
    }
}
',
        'cannot initialize field `f` with `fn() !void`; expected `Callback`')
}