module markused

import os
import v3.flat
import v3.gen.c as cgen
import v3.parser
import v3.pref
import v3.transform
import v3.types

const custom_str_tests_dir = os.dir(@FILE)
const custom_str_v3_dir = os.dir(custom_str_tests_dir)
const custom_str_v3_src = os.join_path(custom_str_v3_dir, 'v3.v')
const custom_str_vexe = @VEXE

// parse_checked_two_file_source reads parse checked two file source input for v3 tests.
fn parse_checked_two_file_source(name string, main_source string, module_rel string, module_source string) (&flat.FlatAst, &types.TypeChecker) {
    root := os.join_path(os.temp_dir(), 'v3_markused_${name}_project')
    if os.exists(root) {
        os.rmdir_all(root) or { panic(err) }
    }
    os.mkdir_all(root) or { panic(err) }
    main_src := os.join_path(root, 'main.v')
    module_src := os.join_path(root, module_rel)
    os.mkdir_all(os.dir(module_src)) or { panic(err) }
    os.write_file(main_src, main_source) or { panic(err) }
    os.write_file(module_src, module_source) or { panic(err) }
    prefs := pref.new_preferences()
    mut p := parser.Parser.new(prefs)
    mut a := p.parse_files([main_src, module_src])
    mut tc := types.TypeChecker.new(a)
    tc.collect(a)
    tc.diagnose_unknown_calls = true
    tc.diagnostic_files[main_src] = true
    tc.diagnostic_files[module_src] = true
    tc.check_semantics()
    assert tc.errors.len == 0, tc.errors.str()
    return a, &tc
}

// build_v3_bin builds v3 bin data for v3 tests.
fn build_v3_bin(name string) string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_markused_${name}')
    build := os.execute('${custom_str_vexe} -o ${v3_bin} ${custom_str_v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

// imported_enum_main_source supports imported enum main source handling for v3 tests.
fn imported_enum_main_source(expr string) string {
    return '
module main

import colors

fn main() {
    c := colors.Color.red
    ${expr}
}
'
}

// imported_optional_enum_main_source
// supports helper handling in v3 tests.
fn imported_optional_enum_main_source(expr string) string {
    return '
module main

import colors

fn maybe_color() ?colors.Color {
    return colors.Color.red
}

fn main() {
    ${expr}
}
'
}

// imported_enum_module_source supports imported enum module source handling for v3 tests.
fn imported_enum_module_source() string {
    return '
module colors

pub enum Color {
    red
    blue
}

pub fn (c Color) str() string {
    return "red"
}
'
}

// imported_operator_main_source supports imported operator main source handling for v3 tests.
fn imported_operator_main_source(expr string) string {
    return '
module main

import vectors

fn main() {
    a := vectors.new_vec(1)
    b := vectors.new_vec(2)
    ${expr}
}
'
}

// imported_operator_module_source supports imported operator module source handling for v3 tests.
fn imported_operator_module_source() string {
    return '
module vectors

pub struct Vec {
    x int
}

pub fn new_vec(x int) Vec {
    return Vec{
        x: x
    }
}

pub fn (a Vec) + (b Vec) Vec {
    return Vec{
        x: a.x + b.x
    }
}

pub fn (a Vec) < (b Vec) bool {
    return a.x < b.x
}
'
}

// imported_operator_usage_source supports imported operator usage source handling for v3 tests.
fn imported_operator_usage_source() string {
    return 'sum := a + b
    gt := b > a
    if gt {
        _ := sum
    }'
}

// imported_struct_default_main_source supports imported_struct_default_main_source handling.
fn imported_struct_default_main_source(expr string) string {
    return '
module main

import defaults

fn main() {
    ${expr}
}
'
}

// imported_struct_default_module_source supports imported_struct_default_module_source handling.
fn imported_struct_default_module_source() string {
    return '
module defaults

pub struct Box {
    value int = default_value()
}

pub fn default_value() int {
    return 7
}

pub fn maybe_box() ?Box {
    return none
}
'
}

// test_string_interpolation_seeds_imported_enum_str_method validates this v3 regression case.
fn test_string_interpolation_seeds_imported_enum_str_method() {
    a, tc := parse_checked_two_file_source('imported_enum_interp_str',
        imported_enum_main_source('_ := "\${c}"'), 'colors/colors.v', imported_enum_module_source())
    mut used := mark_used(a, tc)
    assert used['colors.Color.str']
}

// test_optional_string_interpolation_seeds_imported_enum_str_method
// validates this v3 regression case.
fn test_optional_string_interpolation_seeds_imported_enum_str_method() {
    a, tc := parse_checked_two_file_source('imported_optional_enum_interp_str',
        imported_optional_enum_main_source('_ := "\${maybe_color()}"'), 'colors/colors.v',
        imported_enum_module_source())
    mut used := mark_used(a, tc)
    assert used['colors.Color.str']
}

// test_imported_operator_infix_seeds_operator_methods validates this v3 regression case.
fn test_imported_operator_infix_seeds_operator_methods() {
    a, tc := parse_checked_two_file_source('imported_operator_infix',
        imported_operator_main_source(imported_operator_usage_source()), 'vectors/vectors.v',
        imported_operator_module_source())
    mut used := mark_used(a, tc)
    assert used['vectors.Vec.+']
    assert used['vectors.Vec.<']
}

// test_flag_enum_seeds_string_plus_helper validates this v3 regression case: a `[flag]`
// enum's synthesized `<Enum>__autostr` builds its string with `string__plus`, but that
// generated body is invisible to markused, so the helper must be seeded from the flag-enum
// declaration or it could be pruned and leave the autostr calling an undefined helper.
fn test_flag_enum_seeds_string_plus_helper() {
    main_src := '
module main

import colors

@[flag]
enum Perm {
    read
    write
}

fn main() {
    p := Perm.read | Perm.write
    _ := p
    _ := colors.Color.red
}
'
    a, tc := parse_checked_two_file_source('flag_enum_string_plus', main_src, 'colors/colors.v',
        imported_enum_module_source())
    mut used := mark_used(a, tc)
    assert used['string__plus']
}

// test_optional_struct_zero_seeds_imported_default_helper validates this v3 regression case.
fn test_optional_struct_zero_seeds_imported_default_helper() {
    a, tc := parse_checked_two_file_source('imported_struct_default_or',
        imported_struct_default_main_source('box := defaults.maybe_box() or { return }\n\t_ := box'),
        'defaults/defaults.v', imported_struct_default_module_source())
    mut used := mark_used(a, tc)
    assert used['defaults.default_value']
}

// test_string_interpolation_lowers_to_imported_enum_str_after_used_filter_transform
// validates this v3 regression case.
fn test_string_interpolation_lowers_to_imported_enum_str_after_used_filter_transform() {
    mut a, mut tc := parse_checked_two_file_source('imported_enum_interp_str_cgen',
        imported_enum_main_source('_ := "\${c}"'), 'colors/colors.v', imported_enum_module_source())
    mut used := mark_used(a, tc)
    assert used['colors.Color.str']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('colors__Color__str(')
}

// test_imported_operator_infix_lowers_after_used_filter_transform
// validates this v3 regression case.
fn test_imported_operator_infix_lowers_after_used_filter_transform() {
    mut a, mut tc := parse_checked_two_file_source('imported_operator_infix_cgen',
        imported_operator_main_source(imported_operator_usage_source()), 'vectors/vectors.v',
        imported_operator_module_source())
    mut used := mark_used(a, tc)
    assert used['vectors.Vec.+']
    assert used['vectors.Vec.<']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('vectors__Vec__plus(')
    assert c_code.contains('vectors__Vec__lt(')
}

// test_optional_struct_zero_lowers_to_imported_default_after_used_filter_transform
// validates this v3 regression case.
fn test_optional_struct_zero_lowers_to_imported_default_after_used_filter_transform() {
    mut a, mut tc := parse_checked_two_file_source('imported_struct_default_or_cgen',
        imported_struct_default_main_source('box := defaults.maybe_box() or { return }\n\t_ := box'),
        'defaults/defaults.v', imported_struct_default_module_source())
    mut used := mark_used(a, tc)
    assert used['defaults.default_value']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('defaults__default_value(')
}

// test_optional_string_interpolation_lowers_to_imported_enum_str_after_used_filter_transform
// validates this v3 regression case.
fn test_optional_string_interpolation_lowers_to_imported_enum_str_after_used_filter_transform() {
    mut a, mut tc := parse_checked_two_file_source('imported_optional_enum_interp_str_cgen',
        imported_optional_enum_main_source('_ := "\${maybe_color()}"'), 'colors/colors.v',
        imported_enum_module_source())
    mut used := mark_used(a, tc)
    assert used['colors.Color.str']
    used = transform.transform_with_used(mut a, tc, used)
    tc.diagnose_unknown_calls = false
    tc.reject_unlowered_map_mutation = true
    tc.annotate_types()
    mut g := cgen.FlatGen.new()
    c_code := g.gen_with_used_options(a, used, tc, true)
    assert c_code.contains('colors__Color__str(')
}

// test_imported_enum_print_compile_keeps_str_method validates this v3 regression case.
fn test_imported_enum_print_compile_keeps_str_method() {
    v3_bin := build_v3_bin('imported_enum_print_str_test')

    root := os.join_path(os.temp_dir(), 'v3_markused_imported_enum_print_input')
    if os.exists(root) {
        os.rmdir_all(root) or { panic(err) }
    }
    os.mkdir_all(os.join_path(root, 'colors')) or { panic(err) }
    os.write_file(os.join_path(root, 'main.v'), imported_enum_main_source('println(c)')) or {
        panic(err)
    }
    os.write_file(os.join_path(root, 'colors/colors.v'), imported_enum_module_source()) or {
        panic(err)
    }
    bin := os.join_path(os.temp_dir(), 'v3_markused_imported_enum_print_input_bin')
    compile := os.execute('${v3_bin} -o ${bin} ${root}')
    assert compile.exit_code == 0, compile.output
}

// test_imported_operator_compile_keeps_operator_methods validates this v3 regression case.
fn test_imported_operator_compile_keeps_operator_methods() {
    v3_bin := build_v3_bin('imported_operator_test')

    root := os.join_path(os.temp_dir(), 'v3_markused_imported_operator_input')
    if os.exists(root) {
        os.rmdir_all(root) or { panic(err) }
    }
    os.mkdir_all(os.join_path(root, 'vectors')) or { panic(err) }
    os.write_file(os.join_path(root, 'main.v'),
        imported_operator_main_source(imported_operator_usage_source())) or { panic(err) }
    os.write_file(os.join_path(root, 'vectors/vectors.v'), imported_operator_module_source()) or {
        panic(err)
    }
    bin := os.join_path(os.temp_dir(), 'v3_markused_imported_operator_input_bin')
    compile := os.execute('${v3_bin} -o ${bin} ${root}')
    assert compile.exit_code == 0, compile.output
}

// test_optional_struct_zero_compile_keeps_imported_default_helper
// validates this v3 regression case.
fn test_optional_struct_zero_compile_keeps_imported_default_helper() {
    v3_bin := build_v3_bin('imported_struct_default_or_test')

    root := os.join_path(os.temp_dir(), 'v3_markused_imported_struct_default_or_input')
    if os.exists(root) {
        os.rmdir_all(root) or { panic(err) }
    }
    os.mkdir_all(os.join_path(root, 'defaults')) or { panic(err) }
    os.write_file(os.join_path(root, 'main.v'),
        imported_struct_default_main_source('box := defaults.maybe_box() or { return }\n\t_ := box')) or {
        panic(err)
    }
    os.write_file(os.join_path(root, 'defaults/defaults.v'),
        imported_struct_default_module_source()) or { panic(err) }
    bin := os.join_path(os.temp_dir(), 'v3_markused_imported_struct_default_or_input_bin')
    compile := os.execute('${v3_bin} -o ${bin} ${root}')
    assert compile.exit_code == 0, compile.output
}

// test_imported_optional_enum_interpolation_compile_keeps_str_method
// validates this v3 regression case.
fn test_imported_optional_enum_interpolation_compile_keeps_str_method() {
    v3_bin := build_v3_bin('imported_optional_enum_interp_str_test')

    root := os.join_path(os.temp_dir(), 'v3_markused_imported_optional_enum_interp_input')
    if os.exists(root) {
        os.rmdir_all(root) or { panic(err) }
    }
    os.mkdir_all(os.join_path(root, 'colors')) or { panic(err) }
    os.write_file(os.join_path(root, 'main.v'),
        imported_optional_enum_main_source('_ := "\${maybe_color()}"')) or { panic(err) }
    os.write_file(os.join_path(root, 'colors/colors.v'), imported_enum_module_source()) or {
        panic(err)
    }
    bin := os.join_path(os.temp_dir(), 'v3_markused_imported_optional_enum_interp_input_bin')
    compile := os.execute('${v3_bin} -o ${bin} ${root}')
    assert compile.exit_code == 0, compile.output
}