import os

const directive_order_vexe = @VEXE
const directive_order_tests_dir = os.dir(@FILE)
const directive_order_v3_dir = os.dir(directive_order_tests_dir)
const directive_order_vlib_dir = os.dir(directive_order_v3_dir)
const directive_order_v3_src = os.join_path(directive_order_v3_dir, 'v3.v')

fn directive_order_build_v3() string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_c_directive_order_test')
    build :=
        os.execute('${directive_order_vexe} -gc none -path "${directive_order_vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${directive_order_v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

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

fn directive_order_gen_c(v3_bin string) string {
    root := os.join_path(os.temp_dir(), 'v3_c_directive_order_project')
    os.rmdir_all(root) or {}
    os.mkdir_all(root) or { panic(err) }
    directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order' }\n")
    directive_order_write_file(root, 'main.v', 'module main

import sokol.f as _

fn main() {}
')
    directive_order_write_file(root, 'sokol/c/c.v', 'module c

#define SOKOL_GFX_IMPL
#include "sokol_gfx.h"
')
    directive_order_write_file(root, 'sokol/f/f.v', 'module f

import sokol.c as _

#define SOKOL_FONTSTASH_IMPL
#include "util/sokol_fontstash.h"
#include "sokol_gfx.h"
#ifdef KEEP_DUPLICATE_INCLUDE
#include "sokol_gfx.h"
#endif
')
    c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order.c')
    os.rm(c_out) or {}
    result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
    assert result.exit_code == 0, result.output
    return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_c_dotted_collision(v3_bin string) string {
    root := os.join_path(os.temp_dir(), 'v3_c_directive_order_dotted_collision_project')
    os.rmdir_all(root) or {}
    os.mkdir_all(root) or { panic(err) }
    directive_order_write_file(root, 'v.mod',
        "Module { name: 'directive_order_dotted_collision' }\n")
    directive_order_write_file(root, 'main.v', 'module main

import foo.user as _
import bar as _

fn main() {}
')
    directive_order_write_file(root, 'bar/bar.v', 'module bar

#define SHORT_BAR
')
    directive_order_write_file(root, 'foo/bar/bar.v', 'module bar

#define FOO_BAR
')
    directive_order_write_file(root, 'foo/user/user.v', 'module user

import foo.bar as _

#define FOO_USER
')
    c_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_dotted_collision.c')
    os.rm(c_out) or {}
    result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${c_out}')
    assert result.exit_code == 0, result.output
    return os.read_file(c_out) or { panic(err) }
}

fn directive_order_gen_and_run_importer_macro(v3_bin string) string {
    root := os.join_path(os.temp_dir(), 'v3_c_directive_order_importer_macro_project')
    os.rmdir_all(root) or {}
    os.mkdir_all(root) or { panic(err) }
    directive_order_write_file(root, 'v.mod', "Module { name: 'directive_order_importer_macro' }\n")
    directive_order_write_file(root, 'main.v', 'module main

#define USE_FOO

import wrapper

fn main() {
    println(wrapper.value().str())
}
')
    directive_order_write_file(root, 'wrapper/wrapper.v', 'module wrapper

#include "@DIR/foo.h"

fn C.foo_value() int

pub fn value() int {
    return C.foo_value()
}
')
    directive_order_write_file(root, 'wrapper/foo.h', '#ifndef USE_FOO
#error "USE_FOO must be defined before foo.h"
#endif

static inline int foo_value(void) {
    return 42;
}
')
    bin_out := os.join_path(os.temp_dir(), 'v3_c_directive_order_importer_macro')
    os.rm(bin_out) or {}
    os.rm(bin_out + '.c') or {}
    result := os.execute('${v3_bin} ${os.join_path(root, 'main.v')} -b c -o ${bin_out}')
    assert result.exit_code == 0, result.output
    run := os.execute(bin_out)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == '42', run.output
    return os.read_file(bin_out + '.c') or { panic(err) }
}

fn directive_order_index(c_code string, needle string) int {
    return c_code.index(needle) or { -1 }
}

fn directive_order_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 test_c_directives_follow_import_dependency_order() {
    c_code := directive_order_gen_c(directive_order_build_v3())
    gfx_define := directive_order_index(c_code, '#define SOKOL_GFX_IMPL')
    gfx_include := directive_order_index(c_code, '#include "sokol_gfx.h"')
    fontstash_define := directive_order_index(c_code, '#define SOKOL_FONTSTASH_IMPL')
    fontstash_include := directive_order_index(c_code, '#include "util/sokol_fontstash.h"')
    block_start := directive_order_index(c_code, '#ifdef KEEP_DUPLICATE_INCLUDE')
    assert gfx_define >= 0, c_code
    assert gfx_include >= 0, c_code
    assert fontstash_define >= 0, c_code
    assert fontstash_include >= 0, c_code
    assert block_start >= 0, c_code
    assert gfx_define < gfx_include, c_code
    assert gfx_include < fontstash_define, c_code
    assert fontstash_define < fontstash_include, c_code
    assert directive_order_count(c_code, '#include "sokol_gfx.h"') == 2, c_code
    block_tail := c_code[block_start..]
    block_include := directive_order_index(block_tail, '#include "sokol_gfx.h"')
    block_end := directive_order_index(block_tail, '#endif')
    assert block_include >= 0, c_code
    assert block_end > block_include, c_code
}

fn test_c_directives_preserve_dotted_import_module_identity() {
    c_code := directive_order_gen_c_dotted_collision(directive_order_build_v3())
    short_bar := directive_order_index(c_code, '#define SHORT_BAR')
    foo_bar := directive_order_index(c_code, '#define FOO_BAR')
    foo_user := directive_order_index(c_code, '#define FOO_USER')
    assert short_bar >= 0, c_code
    assert foo_bar >= 0, c_code
    assert foo_user >= 0, c_code
    assert foo_bar < foo_user, c_code
}

fn test_importer_macro_is_emitted_before_dependency_include() {
    c_code := directive_order_gen_and_run_importer_macro(directive_order_build_v3())
    use_foo := directive_order_index(c_code, '#define USE_FOO')
    foo_header := directive_order_index(c_code, 'foo.h"')
    assert use_foo >= 0, c_code
    assert foo_header >= 0, c_code
    assert use_foo < foo_header, c_code
}