import os
import strings

const callback_vexe = @VEXE
const callback_tests_dir = os.dir(@FILE)
const callback_v3_dir = os.dir(callback_tests_dir)
const callback_vlib_dir = os.dir(callback_v3_dir)
const callback_v3_src = os.join_path(callback_v3_dir, 'v3.v')

fn callback_build_v3() string {
    return callback_build_v3_with_flags('serial', '')
}

fn callback_build_v3_parallel() string {
    return callback_build_v3_with_flags('parallel', '-d parallel')
}

fn callback_build_v3_with_flags(name string, flags string) string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_callback_userdata_test_${name}_${os.getpid()}')
    os.rm(v3_bin) or {}
    build :=
        os.execute('${callback_vexe} ${flags} -gc none -path "${callback_vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${callback_v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

fn callback_write_source(name string, source string) string {
    path := os.join_path(os.temp_dir(), 'v3_callback_userdata_${name}_${os.getpid()}.v')
    os.write_file(path, source) or { panic(err) }
    return path
}

fn callback_compile(v3_bin string, source string, name string) os.Result {
    out := os.join_path(os.temp_dir(), 'v3_callback_userdata_${name}_${os.getpid()}')
    return os.execute('${v3_bin} ${source} -b c -o ${out}')
}

fn callback_write_project_file(root string, rel string, source string) string {
    path := os.join_path(root, rel)
    os.mkdir_all(os.dir(path)) or { panic(err) }
    os.write_file(path, source) or { panic(err) }
    return path
}

fn callback_adapter_names(generated string, prefix string) []string {
    mut names := []string{}
    for line in generated.split_into_lines() {
        if line.starts_with('static void ${prefix}') {
            name := line.all_after('static void ').all_before('(')
            if name !in names {
                names << name
            }
        }
    }
    return names
}

fn test_callback_userdata_fn_field_adapters() {
    v3_bin := callback_build_v3()
    good_src := callback_write_source('good', 'module main

struct Event {
    code int
}

struct App {
mut:
    frames int
    events int
    directs int
}

struct Config {
    frame fn (voidptr)
    event fn (&Event, voidptr)
    native_event fn (&Event, voidptr)
    direct fn (voidptr)
    user_data voidptr
}

type FrameAlias = fn (voidptr)
type EventAlias = fn (&Event, voidptr)

struct AliasConfig {
    alias_frame FrameAlias
    alias_event EventAlias
    user_data voidptr
}

struct StructAliasTarget {
    alias2_frame FrameAlias
    alias2_event EventAlias
    user_data voidptr
}

type StructAlias = StructAliasTarget

@[params]
struct Params {
    frame fn (voidptr)
    event fn (&Event, voidptr)
    native_event fn (&Event, voidptr)
    direct fn (voidptr)
    user_data voidptr
}

fn run_config(mut app App, cfg Config) int {
    cfg.frame(cfg.user_data)
    e := Event{code: 3}
    cfg.event(&e, cfg.user_data)
    cfg.native_event(&e, cfg.user_data)
    cfg.direct(cfg.user_data)
    return app.frames + app.events + app.directs
}

fn run_params(mut app App, params Params) int {
    params.frame(params.user_data)
    e := Event{code: 4}
    params.event(&e, params.user_data)
    params.native_event(&e, params.user_data)
    params.direct(params.user_data)
    return app.frames + app.events + app.directs
}

fn use_cb(cb fn (voidptr), data voidptr) {
    cb(data)
}

fn frame(mut app App) {
    app.frames++
}

fn on_event(e &Event, mut app App) {
    app.events += e.code
}

fn erased_event(e voidptr, data voidptr) {
    event := unsafe { &Event(e) }
    mut app := unsafe { &App(data) }
    app.events += event.code * 10
}

fn direct(ptr voidptr) {
    mut app := unsafe { &App(ptr) }
    app.directs++
}

fn main() {
    mut a := App{}
    cfg := Config{
        frame: frame
        event: on_event
        native_event: erased_event
        direct: direct
        user_data: voidptr(&a)
    }
    first := run_config(mut a, cfg)
    mut b := App{}
    second := run_params(mut b, frame: frame, event: on_event, native_event: erased_event, direct: direct, user_data: voidptr(&b))
    mut c := App{}
    use_cb(frame, voidptr(&c))
    alias_cfg := AliasConfig{alias_frame: frame, alias_event: on_event, user_data: voidptr(&c)}
    alias_target := StructAlias{alias2_frame: frame, alias2_event: on_event, user_data: voidptr(&c)}
    if alias_cfg.user_data == voidptr(0) || alias_target.user_data == voidptr(0) {
        println(int_str(-1))
    }
    println(int_str(first + second + c.frames))
}
')
    good_out := os.join_path(os.temp_dir(), 'v3_callback_userdata_good_${os.getpid()}')
    good_compile := os.execute('${v3_bin} ${good_src} -b c -o ${good_out}')
    assert good_compile.exit_code == 0, good_compile.output
    run := os.execute(good_out)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == '82'
    generated := os.read_file(good_out + '.c') or { panic(err) }
    assert generated.contains('callback_adapter'), generated
    assert generated.contains('frame_callback_adapter'), generated
    assert generated.contains('on_event_callback_adapter'), generated
    assert generated.contains('erased_event_callback_adapter'), generated
    assert generated.contains('frame((App*)arg0);'), generated
    assert generated.contains('on_event(arg0, (App*)arg1);'), generated
    assert generated.contains('erased_event((void*)arg0, arg1);'), generated
    assert generated.contains('use_cb(frame_callback_adapter_'), generated
    assert generated.contains('.alias_frame = frame_callback_adapter_'), generated
    assert generated.contains('.alias_event = on_event_callback_adapter_'), generated
    assert generated.contains('.alias2_frame = frame_callback_adapter_'), generated
    assert generated.contains('.alias2_event = on_event_callback_adapter_'), generated
    assert generated.contains('.direct = direct'), generated
    assert !generated.contains('.frame = frame,'), generated
    assert !generated.contains('.event = on_event,'), generated
    assert !generated.contains('.native_event = erased_event,'), generated
    assert !generated.contains('.alias_frame = frame,'), generated
    assert !generated.contains('.alias_event = on_event,'), generated
    assert !generated.contains('.alias2_frame = frame,'), generated
    assert !generated.contains('.alias2_event = on_event,'), generated
    assert !generated.contains('.frame = (_fn_ptr'), generated
    assert !generated.contains('.event = (_fn_ptr'), generated
    assert !generated.contains('.native_event = (_fn_ptr'), generated
    assert !generated.contains('use_cb((_fn_ptr'), generated
    assert !generated.contains('use_cb(frame,'), generated
    assert !generated.contains('direct_callback_adapter'), generated

    wrong_arity := callback_write_source('wrong_arity', 'module main
struct Config {
    frame fn (voidptr)
}
fn wrong(a voidptr, b int) {}
fn main() {
    _ := Config{frame: wrong}
}
')
    arity_compile := callback_compile(v3_bin, wrong_arity, 'wrong_arity')
    assert arity_compile.exit_code != 0, arity_compile.output

    wrong_return := callback_write_source('wrong_return', 'module main
struct Config {
    frame fn (voidptr)
}
fn wrong(a voidptr) int {
    return 1
}
fn main() {
    _ := Config{frame: wrong}
}
')
    return_compile := callback_compile(v3_bin, wrong_return, 'wrong_return')
    assert return_compile.exit_code != 0, return_compile.output

    wrong_return_pointer := callback_write_source('wrong_return_pointer', 'module main
struct Event {}
struct Config {
    cb fn () &Event
}
fn ret_voidptr() voidptr {
    return voidptr(0)
}
fn main() {
    _ := Config{cb: ret_voidptr}
}
')
    return_pointer_compile := callback_compile(v3_bin, wrong_return_pointer, 'wrong_return_pointer')
    assert return_pointer_compile.exit_code != 0, return_pointer_compile.output

    wrong_param := callback_write_source('wrong_param', 'module main
struct Event {}
struct Other {}
struct App {}
struct Config {
    event fn (&Event, voidptr)
}
fn wrong(e &Other, mut app App) {}
fn main() {
    _ := Config{event: wrong}
}
')
    param_compile := callback_compile(v3_bin, wrong_param, 'wrong_param')
    assert param_compile.exit_code != 0, param_compile.output

    wrong_primitive_param := callback_write_source('wrong_primitive_param', 'module main
struct Config {
    cb fn (i64)
}
fn takes_int(x int) {}
fn main() {
    _ := Config{cb: takes_int}
}
')
    primitive_param_compile := callback_compile(v3_bin, wrong_primitive_param,
        'wrong_primitive_param')
    assert primitive_param_compile.exit_code != 0, primitive_param_compile.output

    homonym_root := os.join_path(os.temp_dir(), 'v3_callback_userdata_homonym_${os.getpid()}')
    os.rmdir_all(homonym_root) or {}
    callback_write_project_file(homonym_root, 'left/left.v', 'module left

pub struct App {
pub mut:
    hits int
}

pub fn hit(mut app App) {
    app.hits += 10
}
')
    callback_write_project_file(homonym_root, 'right/right.v', 'module right

pub struct App {
pub mut:
    hits int
}

pub fn hit(mut app App) {
    app.hits += 100
}
')
    homonym_main := callback_write_project_file(homonym_root, 'main.v', 'module main

import left
import right

struct Config {
    cb fn (voidptr)
    user_data voidptr
}

fn run(cfg Config) {
    cfg.cb(cfg.user_data)
}

fn main() {
    _ := left.App{}
    mut app := right.App{}
    cfg := Config{
        cb: right.hit
        user_data: voidptr(&app)
    }
    run(cfg)
    println(int_str(app.hits))
}
')
    homonym_out := os.join_path(os.temp_dir(), 'v3_callback_userdata_homonym_out_${os.getpid()}')
    homonym_compile := os.execute('${v3_bin} ${homonym_main} -b c -o ${homonym_out}')
    assert homonym_compile.exit_code == 0, homonym_compile.output
    homonym_run := os.execute(homonym_out)
    assert homonym_run.exit_code == 0, homonym_run.output
    assert homonym_run.output.trim_space() == '100'
    homonym_c := os.read_file(homonym_out + '.c') or { panic(err) }
    assert homonym_c.contains('right__hit_callback_adapter'), homonym_c
    assert homonym_c.contains('right__hit((right__App*)arg0);'), homonym_c
    assert !homonym_c.contains('left__hit_callback_adapter'), homonym_c

    c_fn_src := callback_write_source('c_fn_value', 'module main

fn C.abs(int) int

struct App {
mut:
    hits int
}

fn abs(mut app App) int {
    app.hits = 99
    return app.hits
}

fn call_c(cb fn (int) int) int {
    return cb(-3)
}

fn main() {
    _ := App{}
    rc := call_c(C.abs)
    println(int_str(rc))
}
')
    c_fn_out := os.join_path(os.temp_dir(), 'v3_callback_userdata_c_fn_${os.getpid()}')
    c_fn_compile := os.execute('${v3_bin} ${c_fn_src} -b c -o ${c_fn_out}')
    assert c_fn_compile.exit_code == 0, c_fn_compile.output
    c_fn_run := os.execute(c_fn_out)
    assert c_fn_run.exit_code == 0, c_fn_run.output
    assert c_fn_run.output.trim_space() == '3'
    c_fn_c := os.read_file(c_fn_out + '.c') or { panic(err) }
    assert c_fn_c.contains('call_c(abs)'), c_fn_c
    assert !c_fn_c.contains('call_c((_fn_ptr'), c_fn_c
    assert !c_fn_c.contains('int abs(App*'), c_fn_c
}

fn test_callback_parallel_wrapper_names_are_stable() {
    v3_bin := callback_build_v3_parallel()
    mut src := strings.new_builder(128 * 1024)
    src.write_string('module main

struct EventA {
    code int
}

struct EventB {
    code int
}

struct App {
mut:
    total int
}

struct ConfigA {
    cb fn (&EventA, voidptr)
    user_data voidptr
}

struct ConfigB {
    cb fn (&EventB, voidptr)
    user_data voidptr
}

fn erased(e voidptr, data voidptr) {
    _ := e
    mut app := unsafe { &App(data) }
    app.total++
}

')
    for i in 0 .. 1100 {
        if i % 2 == 0 {
            src.write_string('fn use_${i}(mut app App) {
    e := EventA{code: ${i}}
    cfg := ConfigA{cb: erased, user_data: voidptr(app)}
    cfg.cb(&e, cfg.user_data)
}

')
        } else {
            src.write_string('fn use_${i}(mut app App) {
    e := EventB{code: ${i}}
    cfg := ConfigB{cb: erased, user_data: voidptr(app)}
    cfg.cb(&e, cfg.user_data)
}

')
        }
    }
    src.write_string('fn main() {
    mut app := App{}
')
    for i in 0 .. 1100 {
        src.write_string('    use_${i}(mut app)
')
    }
    src.write_string('    println(int_str(app.total))
}
')
    parallel_src := callback_write_source('parallel', src.str())
    parallel_out := os.join_path(os.temp_dir(), 'v3_callback_userdata_parallel_${os.getpid()}')
    parallel_compile := os.execute('${v3_bin} ${parallel_src} -b c -o ${parallel_out}')
    assert parallel_compile.exit_code == 0, parallel_compile.output
    parallel_run := os.execute(parallel_out)
    assert parallel_run.exit_code == 0, parallel_run.output
    assert parallel_run.output.trim_space() == '1100'
    parallel_c := os.read_file(parallel_out + '.c') or { panic(err) }
    names := callback_adapter_names(parallel_c, 'erased_callback_adapter_')
    assert names.len == 2, parallel_c
    assert names[0] != names[1]
}