import os

const vexe = @VEXE

fn test_skip_unused_prunes_unused_generic_fn_instantiations() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v_issue_26019')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    source_path := os.join_path(tmp_dir, 'issue_26019.v')
    source := [
        'module main',
        '',
        'fn new[T]() map[u8]T {',
        '\tx := map[u8]T{}',
        '\treturn x',
        '}',
        '',
        'fn not_used_fn() map[u8]int {',
        '\tx := new[int]()',
        '\treturn x',
        '}',
        '',
        'fn main() {',
        '\tx := new[u32]()',
        '\tdump(x)',
        '}',
    ].join('\n')
    os.write_file(source_path, source) or { panic(err) }
    res := os.execute('${os.quoted_path(vexe)} -o - ${os.quoted_path(source_path)}')
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('VV_LOC Map_u8_u32 main__new_T_u32(void)')
    assert !res.output.contains('VV_LOC Map_u8_int main__new_T_int(void)')
}

fn test_skip_unused_does_not_emit_impl_methods_for_interface_extensions() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v_skip_unused_interface_extension_collision')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    source_path := os.join_path(tmp_dir, 'interface_extension_collision.v')
    source := [
        'module main',
        '',
        'import crypto.internal.subtle',
        '',
        'interface Elem {}',
        '',
        'struct Thing {}',
        '',
        'struct Holder {',
        '\titems []Elem',
        '}',
        '',
        'fn (el Elem) equal(_ Elem) bool {',
        '\treturn true',
        '}',
        '',
        'fn (t Thing) equal(_ Thing) bool {',
        '\treturn subtle.constant_time_compare([u8(1)], [u8(1)]) == 1',
        '}',
        '',
        'fn (h Holder) ok() bool {',
        '\tfor i, item in h.items {',
        '\t\tfor j, obj in h.items {',
        '\t\t\tif i == j {',
        '\t\t\t\treturn item.equal(obj)',
        '\t\t\t}',
        '\t\t}',
        '\t}',
        '\treturn false',
        '}',
        '',
        'fn main() {',
        '\th := Holder{items: [Elem(Thing{}), Elem(Thing{})]}',
        '\tprintln(h.ok())',
        '}',
    ].join('\n')
    os.write_file(source_path, source) or { panic(err) }
    res := os.execute('${os.quoted_path(vexe)} -o - ${os.quoted_path(source_path)}')
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('VV_LOC bool main__Elem_equal(')
    assert !res.output.contains('main__Thing_equal(')
}

fn test_skip_unused_keeps_json2_embedded_struct_decode_helpers() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v_issue_26928')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    source_path := os.join_path(tmp_dir, 'issue_26928.v')
    source := [
        'module main',
        '',
        'import time',
        'import x.json2',
        '',
        'struct Meta {',
        '\tcreated_at ?time.Time',
        '}',
        '',
        'struct Req {',
        '\tMeta',
        '\tname string',
        '}',
        '',
        'fn main() {',
        '\t_ := json2.decode[Req](\'{"name":"x"}\') or { panic(err) }',
        '}',
    ].join('\n')
    os.write_file(source_path, source) or { panic(err) }
    res := os.execute('${os.quoted_path(vexe)} -w -o - ${os.quoted_path(source_path)}')
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('x__json2__decode_struct_key_T_main__Req')
    assert res.output.contains('x__json2__check_required_struct_fields_T_main__Req')
    assert res.output.contains('x__json2__create_value_from_optional_T_time__Time')
}

fn test_skip_unused_marks_dependencies_inside_generic_anon_fns() {
    tmp_dir := os.join_path(os.vtmp_dir(), 'v_generic_anon_fn_dependencies')
    os.mkdir_all(tmp_dir) or { panic(err) }
    defer {
        os.rmdir_all(tmp_dir) or {}
    }
    source_path := os.join_path(tmp_dir, 'generic_anon_fn_dependencies.v')
    binary_path := os.join_path(tmp_dir, 'generic_anon_fn_dependencies')
    source := [
        'module main',
        '',
        'struct Holder[T] {',
        '\tdata []T',
        '}',
        '',
        'fn (h &Holder[T]) nmap[T](others []&Holder[T], f fn ([]T) T) T {',
        '\treturn f([h.data[0], others[0].data[0]])',
        '}',
        '',
        'fn (a &Holder[T]) subtract[T](b &Holder[T]) T {',
        '\treturn a.nmap([b], fn [T] (xs []T) T {',
        '\t\tx := xs[0]',
        '\t\ty := xs[1]',
        '\t\t$if T is string {',
        "\t\t\treturn x.replace(y, '')",
        '\t\t} $else {',
        '\t\t\treturn x - y',
        '\t\t}',
        '\t})',
        '}',
        '',
        'fn unused_string() {',
        "\ta := &Holder[string]{data: ['abc']}",
        "\tb := &Holder[string]{data: ['b']}",
        '\tprintln(a.subtract(b))',
        '}',
        '',
        'fn main() {',
        '\ta := &Holder[int]{data: [1]}',
        '\tb := &Holder[int]{data: [2]}',
        '\tprintln(a.subtract(b))',
        '}',
    ].join('\n')
    os.write_file(source_path, source) or { panic(err) }
    res :=
        os.execute('${os.quoted_path(vexe)} -d no_backtrace -o ${os.quoted_path(binary_path)} ${os.quoted_path(source_path)}')
    if res.exit_code != 0 {
        panic(res.output)
    }
}