import os

const selective_import_vexe = @VEXE
const selective_import_tests_dir = os.dir(@FILE)
const selective_import_v3_dir = os.dir(selective_import_tests_dir)
const selective_import_vlib_dir = os.dir(selective_import_v3_dir)
const selective_import_v3_src = os.join_path(selective_import_v3_dir, 'v3.v')

fn selective_import_build_v3() string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_selective_import_test_${os.getpid()}')
    os.rm(v3_bin) or {}
    build :=
        os.execute('${selective_import_vexe} -gc none -path "${selective_import_vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${selective_import_v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

fn selective_import_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 selective_import_write_project(name string, main_src string) string {
    return selective_import_write_project_with_extra(name, main_src, {})
}

fn selective_import_write_project_with_extra(name string, main_src string, extra_files map[string]string) string {
    root := os.join_path(os.temp_dir(), 'v3_selective_import_${name}_${os.getpid()}')
    os.rmdir_all(root) or {}
    selective_import_write_file(root, 'v.mod', "Module { name: 'selective_import_test' }\n")
    selective_import_write_file(root, 'mymodules/main_functions.v', 'module mymodules

pub fn add_xy(x int, y int) int {
    return x + y
}

pub fn hidden_xy(x int, y int) int {
    return x * 100 + y
}
')
    selective_import_write_file(root, 'mymodules/submodule/sub_functions.v', 'module submodule

pub fn sub_xy(x int, y int) int {
    return x - y
}
')
    selective_import_write_file(root, 'main.v', main_src)
    for rel, src in extra_files {
        selective_import_write_file(root, rel, src)
    }
    return root
}

fn selective_import_compile_run(v3_bin string, name string, main_src string) (string, string) {
    root := selective_import_write_project(name, main_src)
    return selective_import_compile_run_root(v3_bin, root)
}

fn selective_import_compile_run_with_extra(v3_bin string, name string, main_src string, extra_files map[string]string) (string, string) {
    root := selective_import_write_project_with_extra(name, main_src, extra_files)
    return selective_import_compile_run_root(v3_bin, root)
}

fn selective_import_compile_run_root(v3_bin string, root string) (string, string) {
    bin := os.join_path(root, 'out')
    compile := os.execute('${v3_bin} ${root} -b c -o ${bin}')
    assert compile.exit_code == 0, compile.output
    run := os.execute(bin)
    assert run.exit_code == 0, run.output
    generated := os.read_file(bin + '.c') or { panic(err) }
    return run.output.trim_space(), generated
}

fn selective_import_compile_bad(v3_bin string, name string, main_src string) string {
    root := selective_import_write_project(name, main_src)
    return selective_import_compile_bad_root(v3_bin, name, root)
}

fn selective_import_compile_bad_with_extra(v3_bin string, name string, main_src string, extra_files map[string]string) string {
    root := selective_import_write_project_with_extra(name, main_src, extra_files)
    return selective_import_compile_bad_root(v3_bin, name, root)
}

fn selective_import_compile_bad_root(v3_bin string, name string, root string) string {
    bin := os.join_path(root, 'out')
    compile := os.execute('${v3_bin} ${root} -b c -o ${bin}')
    assert compile.exit_code != 0, '${name}: compile unexpectedly succeeded: ${compile.output}'
    assert !compile.output.contains('C compilation failed'), compile.output
    return compile.output
}

fn selective_import_ambiguous_modules() map[string]string {
    return {
        'a/a.v': 'module a

pub fn hit() int {
    return 1
}
'
        'b/b.v': 'module b

pub fn hit() int {
    return 2
}
'
    }
}

fn selective_import_type_collision_modules() map[string]string {
    return {
        'geometry/geometry.v': 'module geometry

pub struct Point {
pub:
    x int
}

pub struct Size {
pub:
    w int
}

pub type ItemId = int

pub enum Mode {
    on = 7
    off = 8
}

@[flag]
pub enum Perm {
    a
    b
}

pub struct Box[T] {
pub:
    value T
}
'
        'pixels/pixels.v':     'module pixels

pub struct Point {
pub:
    x int
}

pub struct Size {
pub:
    w int
}

pub type ItemId = int

pub enum Mode {
    on = 70
    off = 80
}

@[flag]
pub enum Perm {
    a
    c
    b
}

pub struct Box[T] {
pub:
    other T
}
'
    }
}

fn test_selective_import_calls_module_and_submodule_functions() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run(v3_bin, 'positive', 'module main

import mymodules { add_xy }
import mymodules.submodule { sub_xy }

fn main() {
    println(int_str(add_xy(2, 3)))
    println(int_str(sub_xy(10, 7)))
}
')
    assert output == '5\n3'
    assert generated.contains('mymodules__add_xy(2, 3)'), generated
    assert generated.contains('submodule__sub_xy(10, 7)'), generated
}

fn test_selective_import_inside_generic_clone_keeps_source_file_symbol() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'generic_clone_selective_import', 'module main

import worker

fn main() {
    println(int_str(worker.use_add[int](0, 2, 3)))
}
', {
        'worker/worker.v': 'module worker

import mymodules { add_xy }
import other

pub fn use_add[T](marker T, x int, y int) int {
    _ = marker
    return add_xy(x, y)
}
'
        'other/other.v':   'module other

pub fn add_xy(x int, y int) int {
    return x * 100 + y
}
'
    })
    assert output == '5'
    assert generated.contains('mymodules__add_xy(x, y)'), generated
    assert !generated.contains('other__add_xy(x, y)'), generated
}

fn test_selective_import_explicit_generic_call_keeps_selected_symbol() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'explicit_generic_selective_import', 'module main

import util { id }
import other

fn main() {
    println(int_str(id[int](1)))
}
', {
        'util/util.v':   'module util

pub fn id[T](x T) T {
    return x
}
'
        'other/other.v': 'module other

pub fn id[T](x T) T {
    return x
}
'
    })
    assert output == '1'
    assert generated.contains('util__id_T_v_int(1)'), generated
    assert !generated.contains('other__id_T_v_int(1)'), generated
}

fn test_selective_import_fn_value_inside_generic_clone_keeps_source_file_symbol() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'generic_clone_selective_import_fn_value', 'module main

import worker

fn main() {
    println(int_str(worker.use_add_cb[int](0, 2, 3)))
}
', {
        'worker/worker.v': 'module worker

import mymodules { add_xy }
import other

fn takes(cb fn (int, int) int, x int, y int) int {
    return cb(x, y)
}

pub fn use_add_cb[T](marker T, x int, y int) int {
    _ = marker
    return takes(add_xy, x, y)
}
'
        'other/other.v':   'module other

pub fn add_xy(x int, y int) int {
    return x * 100 + y
}
'
    })
    assert output == '5'
    assert generated.contains('worker__takes(mymodules__add_xy, x, y)'), generated
    assert !generated.contains('worker__takes(add_xy, x, y)'), generated
    assert !generated.contains('worker__takes(other__add_xy, x, y)'), generated
}

fn test_selective_import_type_inside_generic_clone_signature_keeps_source_file_symbol() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'generic_clone_selective_import_type_signature', 'module main

import worker

fn main() {
    p := worker.make_point[int](7)
    println(int_str(worker.take_point[int](p, 2) + p.x))
}
', {
        'worker/worker.v':     'module worker

import geometry { Point }
import pixels

pub fn make_point[T](x T) Point {
    _ = x
    return Point{
        x: 3
    }
}

pub fn take_point[T](p Point, x T) int {
    _ = x
    return p.x + 4
}
'
        'geometry/geometry.v': 'module geometry

pub struct Point {
pub:
    x int
}
'
        'pixels/pixels.v':     'module pixels

pub struct Point {
pub:
    x int
}
'
    })
    assert output == '10'
    assert generated.contains('geometry__Point worker__make_point_T_v_int(int x)'), generated
    assert generated.contains('int worker__take_point_T_v_int(geometry__Point p, int x)'), generated
    assert !generated.contains('\nPoint worker__make_point_T_v_int(int x)'), generated
    assert !generated.contains('\npixels__Point worker__make_point_T_v_int(int x)'), generated
    assert !generated.contains('\nint worker__take_point_T_v_int(Point p, int x)'), generated
    assert !generated.contains('\nint worker__take_point_T_v_int(pixels__Point p, int x)'), generated
}

fn test_selective_import_symbol_can_be_used_as_function_value() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run(v3_bin, 'fn_value', 'module main

import mymodules { add_xy }

fn main() {
    f := add_xy
    println(int_str(f(2, 3)))
}
')
    assert output == '5'
    assert generated.contains('mymodules__add_xy'), generated
    assert generated.contains('f(2, 3)'), generated
    assert !generated.contains('int f = mymodules__add_xy'), generated
}

fn test_selective_import_function_value_roots_exact_symbol_with_imported_homonym() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'fn_value_imported_homonym', 'module main

import a { choose }
import b

fn main() {
    f := choose
    println(int_str(f()))
}
', {
        'a/a.v': 'module a

pub fn choose() int {
    return 11
}
'
        'b/b.v': 'module b

pub fn choose() int {
    return 99
}
'
    })
    assert output == '11'
    assert generated.contains('a__choose'), generated
    assert !generated.contains('b__choose'), generated
}

fn test_selective_import_does_not_import_other_symbols_by_suffix() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad(v3_bin, 'hidden_symbol', 'module main

import mymodules { add_xy }

fn main() {
    println(int_str(hidden_xy(2, 3)))
}
')
    assert output.contains('unknown function `hidden_xy`'), output
}

fn test_selective_import_scope_is_file_local() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'file_local', 'module main

import mymodules { add_xy }

fn main() {
    println(int_str(add_xy(1, 2)))
}
', {
        'other.v': 'module main

fn from_other_file() int {
    return add_xy(3, 4)
}
'
    })
    assert output.contains('unknown function `add_xy`'), output
}

fn test_selective_import_same_symbol_from_two_modules_is_ambiguous() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'ambiguous_symbol', 'module main

import a { hit }
import b { hit }

fn main() {
    println(int_str(hit()))
}
',
        selective_import_ambiguous_modules())
    assert output.contains('ambiguous selective import `hit`'), output
}

fn test_duplicate_selective_import_fails_even_when_unused() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'ambiguous_unused', 'module main

import a { hit }
import b { hit }

fn main() {
    println("ok")
}
',
        selective_import_ambiguous_modules())
    assert output.contains('ambiguous selective import `hit`'), output
}

fn test_duplicate_selective_import_fails_even_with_local_homonym() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'ambiguous_local_homonym', 'module main

import a { hit }
import b { hit }

fn hit() int {
    return 3
}

fn main() {
    println(int_str(hit()))
}
',
        selective_import_ambiguous_modules())
    assert output.contains('ambiguous selective import `hit`'), output
}

fn test_duplicate_selective_import_function_value_reports_ambiguous() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'ambiguous_fn_value', 'module main

import a { hit }
import b { hit }

fn main() {
    f := hit
    println(int_str(f()))
}
',
        selective_import_ambiguous_modules())
    assert output.contains('ambiguous selective import `hit`'), output
    assert !output.contains('unknown identifier `hit`'), output
}

fn test_local_function_keeps_priority_over_selective_import_homonym() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run(v3_bin, 'local_homonym', 'module main

import mymodules { add_xy }

fn add_xy(x int, y int) int {
    return x * y
}

fn main() {
    println(int_str(add_xy(2, 3)))
}
')
    assert output == '6'
    assert generated.contains('int add_xy(int x, int y)'), generated
    assert generated.contains('int__str(add_xy(2, 3))'), generated
    assert !generated.contains('int__str(mymodules__add_xy(2, 3))'), generated
}

fn test_module_homonym_function_signature_uses_module_key() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'module_homonym_signature', 'module main

import foo

fn value() int {
    return 7
}

fn main() {
    println(int_str(value()))
    println(foo.value())
}
', {
        'foo/foo.v': 'module foo

pub fn value() string {
    return "foo"
}
'
    })
    assert output == '7\nfoo'
    assert generated.contains('int value(void);'), generated
    assert generated.contains('string foo__value(void);'), generated
    assert generated.contains('string foo__value(void) {'), generated
    assert !generated.contains('int foo__value(void);'), generated
}

fn test_selective_import_with_module_alias_keeps_symbol_authority() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run(v3_bin, 'alias', 'module main

import mymodules as mm { add_xy }

fn main() {
    println(int_str(add_xy(4, 5)))
}
')
    assert output == '9'
    assert generated.contains('mymodules__add_xy(4, 5)'), generated
    assert !generated.contains('mm__add_xy'), generated
}

fn test_selective_import_resolves_struct_collision() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin, 'struct_collision', 'module main

import geometry { Point }
import pixels

fn main() {
    p := Point{x: 7}
    println(int_str(p.x))
}
',
        selective_import_type_collision_modules())
    assert output == '7'
    assert generated.contains('geometry__Point p ='), generated
    assert !generated.contains('pixels__Point p ='), generated
}

fn test_selective_import_resolves_generic_struct_collision() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'generic_struct_collision', 'module main

import geometry { Box }
import pixels

fn main() {
    b := Box[int]{value: 7}
    p := pixels.Box[int]{other: 8}
    println(int_str(b.value + p.other))
}
',
        selective_import_type_collision_modules())
    assert output == '15'
    assert generated.contains('struct geometry__Box_int'), generated
    assert generated.contains('struct pixels__Box_int'), generated
    assert generated.contains('geometry__Box_int b ='), generated
    assert generated.contains('pixels__Box_int p ='), generated
}

fn test_selective_import_resolves_generic_struct_field_from_decl_file() {
    v3_bin := selective_import_build_v3()
    extra := {
        'types/types.v': 'module types

pub struct Thing {
pub:
    v int
}
'
        'other/other.v': 'module other

pub struct Thing {
pub:
    v int
}
'
        'box/box.v':     'module box

import types { Thing }

pub struct Box[T] {
pub:
    thing Thing
    value T
}
'
    }
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'generic_struct_field_selective_import', 'module main

import box { Box }
import other

fn main() {
    b := Box[int]{value: 7}
    o := other.Thing{v: 8}
    println(int_str(b.value + o.v))
}
',
        extra)
    assert output == '15'
    assert generated.contains('struct box__Box_int'), generated
    assert generated.contains('types__Thing thing;'), generated
    assert !generated.contains('box__Thing thing;'), generated
    assert !generated.contains('other__Thing thing;'), generated
}

fn test_selective_import_resolves_generic_struct_method_signature_from_decl_file() {
    v3_bin := selective_import_build_v3()
    extra := {
        'types/types.v': 'module types

pub struct Thing {
pub:
    v int
}
'
        'other/other.v': 'module other

pub struct Thing {
pub:
    v int
}
'
        'box/box.v':     'module box

import types { Thing }

pub struct Box[T] {
pub:
    thing Thing
    value T
}

pub fn (b Box[T]) combine(thing Thing) int {
    return b.value + thing.v
}
'
    }
    output, generated := selective_import_compile_run_with_extra(v3_bin,
        'generic_struct_method_signature_selective_import', 'module main

import box { Box }
import other

fn main() {
    b := Box[int]{value: 7}
    _ := other.Thing{v: 1}
    println(int_str(b.combine(b.thing)))
}
',
        extra)
    assert output == '7'
    assert generated.contains('int box__Box_int__combine(box__Box_int b, types__Thing thing)'), generated
    assert !generated.contains('int box__Box_int__combine(box__Box_int b, box__Thing thing)'), generated
    assert !generated.contains('int box__Box_int__combine(box__Box_int b, other__Thing thing)'), generated
}

fn test_selective_import_resolves_alias_collision() {
    v3_bin := selective_import_build_v3()
    output, _ := selective_import_compile_run_with_extra(v3_bin, 'alias_collision', 'module main

import geometry { ItemId }
import pixels

fn value(id ItemId) int {
    return int(id)
}

fn main() {
    println(int_str(value(ItemId(9))))
}
',
        selective_import_type_collision_modules())
    assert output == '9'
}

fn test_selective_import_resolves_enum_collision() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin, 'enum_collision', 'module main

import geometry { Mode }
import pixels

fn is_on(mode Mode) bool {
    return mode == .on
}

fn main() {
    if is_on(.on) {
        println("on")
    }
}
',
        selective_import_type_collision_modules())
    assert output == 'on'
    assert generated.contains('return mode == 7;'), generated
    assert generated.contains('is_on(7)'), generated
    assert !generated.contains('return mode == 70;'), generated
    assert !generated.contains('is_on(70)'), generated
}

fn test_selective_import_resolves_flag_enum_collision() {
    v3_bin := selective_import_build_v3()
    output, generated := selective_import_compile_run_with_extra(v3_bin, 'flag_enum_collision', 'module main

import geometry { Perm }
import pixels

fn main() {
    m := Perm.a | .b
    println(int_str(int(m)))
}
',
        selective_import_type_collision_modules())
    assert output == '3'
    assert generated.contains('int m = 1 | 2;'), generated
    assert !generated.contains('int m = 1 | 4;'), generated
    assert !generated.contains('Perm.a'), generated
}

fn test_duplicate_selective_import_type_fails() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'ambiguous_type', 'module main

import geometry { Point }
import pixels { Point }

fn main() {
    p := Point{x: 1}
    println(int_str(p.x))
}
',
        selective_import_type_collision_modules())
    assert output.contains('ambiguous selective import `Point`'), output
}

fn test_duplicate_selective_import_enum_selector_fails() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'ambiguous_enum_selector', 'module main

import geometry { Mode }
import pixels { Mode }

fn main() {
    mode := Mode.on
    println(int_str(int(mode)))
}
',
        selective_import_type_collision_modules())
    assert output.contains('ambiguous selective import `Mode`'), output
}

fn test_selective_import_enum_selector_keeps_selected_authority() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'enum_selector_authority', 'module main

import geometry { Mode }
import pixels

fn takes_pixel(mode pixels.Mode) {}

fn main() {
    takes_pixel(Mode.on)
}
',
        selective_import_type_collision_modules())
    assert output.contains('cannot use `geometry.Mode` as argument 1 to `takes_pixel`; expected `pixels.Mode`'), output
}

fn test_unselected_type_from_selective_import_is_not_resolved_by_suffix() {
    v3_bin := selective_import_build_v3()
    output := selective_import_compile_bad_with_extra(v3_bin, 'unselected_type', 'module main

import geometry { Point }
import pixels

fn use_size(s Size) int {
    return s.w
}

fn main() {
    println("ok")
}
',
        selective_import_type_collision_modules())
    assert output.contains('unknown type `Size`'), output
}