import os

const vexe = @VEXE
const tests_dir = os.dir(@FILE)
const v3_dir = os.dir(tests_dir)
const vlib_dir = os.dir(v3_dir)
const v3_src = os.join_path(v3_dir, 'v3.v')

// build_v3 builds v3 data for v3 tests.
fn build_v3() string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_generics_test')
    build := os.execute('${vexe} -path "${vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

// run_selfhost_bad supports run selfhost bad handling for v3 tests.
fn run_selfhost_bad(v3_bin string, name string, src string, expected string) {
    bad_src := os.join_path(os.temp_dir(), 'v3_gen_${name}.v')
    os.write_file(bad_src, src) or { panic(err) }
    bad_bin := os.join_path(os.temp_dir(), 'v3_gen_${name}')
    result := os.execute('${v3_bin} ${bad_src} -selfhost -b c -o ${bad_bin}')
    assert result.exit_code != 0, 'expected error for ${name}, but compilation succeeded'
    assert result.output.contains(expected), 'expected "${expected}" in output for ${name}, got: ${result.output}'
    assert !result.output.contains('C compilation failed')
}

fn write_project_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 run_selfhost_project_bad(v3_bin string, name string, files map[string]string, input string, expected string) {
    root := os.join_path(os.temp_dir(), 'v3_gen_${name}_project')
    os.rmdir_all(root) or {}
    os.mkdir_all(root) or { panic(err) }
    for rel, src in files {
        write_project_file(root, rel, src)
    }
    input_path := os.join_path(root, input)
    bad_bin := os.join_path(os.temp_dir(), 'v3_gen_${name}')
    result := os.execute('${v3_bin} ${input_path} -selfhost -b c -o ${bad_bin}')
    assert result.exit_code != 0, 'expected error for ${name}, but compilation succeeded'
    assert result.output.contains(expected), 'expected "${expected}" in output for ${name}, got: ${result.output}'
    assert !result.output.contains('C compilation failed')
}

// run_no_generic_error supports run no generic error handling for v3 tests.
fn run_no_generic_error(v3_bin string, name string, src string) {
    src_file := os.join_path(os.temp_dir(), 'v3_gen_${name}.v')
    os.write_file(src_file, src) or { panic(err) }
    bin_file := os.join_path(os.temp_dir(), 'v3_gen_${name}')
    result := os.execute('${v3_bin} ${src_file} -b c -o ${bin_file}')
    assert !result.output.contains('unsupported generic'), '${name}: should not reject generics without -selfhost, got: ${result.output}'
}

// run_generic_ok supports run generic ok handling for v3 tests.
fn run_generic_ok(v3_bin string, name string, src string, expected string) {
    src_file := os.join_path(os.temp_dir(), 'v3_gen_${name}.v')
    os.write_file(src_file, src) or { panic(err) }
    bin_file := os.join_path(os.temp_dir(), 'v3_gen_${name}')
    c_file := bin_file + '.c'
    compile := os.execute('${v3_bin} ${src_file} -b c -o ${bin_file}')
    // Check that v3 type checker and transform pass without errors
    assert !compile.output.contains('unsupported generic'), '${name}: should not reject generics, got: ${compile.output}'
    assert !compile.output.contains('type checker found'), '${name}: type checker errors: ${compile.output}'
    // Verify C file was generated. The v3 pipeline can succeed even if cc fails due
    // to pre-existing runtime issues.
    assert os.exists(c_file), '${name}: C file not generated'
    c_content := os.read_file(c_file) or { '' }
    // The mangled generic function should appear in the generated C code
    if expected.len > 0 {
        assert c_content.len > 0, '${name}: empty C file'
    }
}

fn run_generic_exec(v3_bin string, name string, src string) string {
    src_file := os.join_path(os.temp_dir(), 'v3_gen_${name}.v')
    os.write_file(src_file, src) or { panic(err) }
    bin_file := os.join_path(os.temp_dir(), 'v3_gen_${name}')
    compile := os.execute('${v3_bin} ${src_file} -b c -o ${bin_file}')
    assert compile.exit_code == 0, compile.output
    run := os.execute(bin_file)
    assert run.exit_code == 0, run.output
    return run.output.trim_space()
}

// test_generics_rejected_when_building_v validates this v3 regression case.
fn test_generics_rejected_when_building_v() {
    v3_bin := build_v3()
    // generic function
    run_selfhost_bad(v3_bin, 'generic_fn', '
fn id[T](x T) T {
    return x
}
fn main() {
    println(id[int](1))
}
',
        'unsupported generic')

    // generic struct
    run_selfhost_bad(v3_bin, 'generic_struct', '
struct Box[T] {
    value T
}
fn main() {
    b := Box[int]{value: 7}
    println(b.value)
}
    ',
        'unsupported generic')

    // generic struct with no generic fields
    run_selfhost_bad(v3_bin, 'generic_struct_marker_only', '
struct Phantom[T] {
    value int
}
fn main() {}
',
        'unsupported generic struct `Phantom`')

    run_selfhost_bad(v3_bin, 'generic_fn_marker_only', '
fn unused[T]() {}
fn main() {}
    ',
        'unsupported generic declaration `unused`')

    run_selfhost_bad(v3_bin, 'generic_c_fn_marker_only', '
fn helper[T]()
fn main() {}
    ',
        'unsupported generic declaration `helper`')

    run_selfhost_bad(v3_bin, 'generic_interface_marker_only', '
interface I[T] {}
fn main() {}
    ',
        'unsupported generic declaration `I`')

    run_selfhost_bad(v3_bin, 'generic_type_alias_marker_only', '
type Alias[T] = int
fn main() {}
',
        'unsupported generic declaration `Alias`')

    // generic method
    run_selfhost_bad(v3_bin, 'generic_method', '
struct Box[T] {
    value T
}
fn (b Box[T]) get() T {
    return b.value
}
fn main() {
    b := Box[string]{value: "v3"}
    println(b.get())
}
',
        'unsupported generic')

    // generic with option/result return
    run_selfhost_bad(v3_bin, 'generic_option', '
fn maybe[T](x T) ?T {
    return x
}
fn main() {
    x := maybe[int](1) or { 0 }
    println(x)
}
',
        'unsupported generic')

    // multiple type parameters
    run_selfhost_bad(v3_bin, 'generic_multi_param', '
fn pair[A, B](a A, b B) A {
    return a
}
fn main() {
    _ := pair[int, string](1, "ok")
}
',
        'unsupported generic')

    // generic type application in params
    run_selfhost_bad(v3_bin, 'generic_param_type', '
fn takes_box(x Box[int]) {}
fn main() {}
',
        'unsupported generic type application `Box[int]`')

    // generic struct field
    run_selfhost_bad(v3_bin, 'generic_field_type', '
struct Wrapper {
    inner Box[string]
}
fn main() {}
',
        'unsupported generic type application `Box[string]`')

    // generic return type
    run_selfhost_bad(v3_bin, 'generic_return_type', '
fn make_box() Box[int] {
    return Box[int]{}
}
fn main() {}
',
        'unsupported generic type application `Box[int]`')

    // generic sum type
    run_selfhost_bad(v3_bin, 'generic_type_decl', '
type Result[T] = T | string
fn main() {}
',
        'unsupported generic')

    // generic interface
    run_selfhost_bad(v3_bin, 'generic_interface', '
interface Container[T] {
    get() T
}
fn main() {}
',
        'unsupported generic')

    run_selfhost_project_bad(v3_bin, 'imported_generic_struct', {
        'main.v':          'module main

import badmod

fn main() {}
'
        'badmod/badmod.v': 'module badmod

struct Phantom[T] {
    value int
}
'
    }, 'main.v', 'unsupported generic struct `Phantom`')
}

// test_generics_allowed_without_building_v validates this v3 regression case.
fn test_generics_allowed_without_building_v() {
    v3_bin := build_v3()
    // generic function — no "unsupported generic" error
    run_no_generic_error(v3_bin, 'allow_generic_fn', '
fn id[T](x T) T {
    return x
}
fn main() {
    _ := id[int](1)
}
')

    // generic struct
    run_no_generic_error(v3_bin, 'allow_generic_struct', '
struct Box[T] {
    value T
}
fn main() {
    b := Box[int]{value: 7}
    _ := b
}
')

    // generic method
    run_no_generic_error(v3_bin, 'allow_generic_method', '
struct Box[T] {
    value T
}
fn (b Box[T]) get() T {
    return b.value
}
fn main() {
    b := Box[string]{value: "v3"}
    _ := b
}
')

    // nested generic type
    run_no_generic_error(v3_bin, 'allow_generic_nested', '
struct Box[T] {
    value T
}
fn main() {
    b := Box[[]int]{value: [1, 2, 3]}
    _ := b
}
')

    // option/result generic
    run_no_generic_error(v3_bin, 'allow_generic_option', '
fn maybe[T](x T) ?T {
    return x
}
fn main() {
    x := maybe[int](1) or { 0 }
    _ := x
}
')

    // generic type in params/fields/returns
    run_no_generic_error(v3_bin, 'allow_generic_type_app', '
fn takes_box(x Box[int]) {}
fn main() {}
')

    // generic interface
    run_no_generic_error(v3_bin, 'allow_generic_interface', '
interface Container[T] {
    get() T
}
fn main() {}
')
}

// test_generics_compile_and_run validates generics compile and run behavior in v3 tests.
fn test_generics_compile_and_run() {
    v3_bin := build_v3()

    // identity function with int and string
    run_generic_ok(v3_bin, 'run_id_fn', '
fn id[T](x T) T {
    return x
}
fn main() {
    println(id(123))
    println(id("ok"))
}
',
        '123\nok')

    // generic struct with field access
    run_generic_ok(v3_bin, 'run_generic_struct', '
struct Box[T] {
    value T
}
fn main() {
    b := Box[string]{value: "v3"}
    println(b.value)
}
',
        'v3')

    // A one-letter concrete type argument should not be treated as an unresolved
    // generic placeholder when discovering struct specializations.
    one_letter_src := os.join_path(os.temp_dir(), 'v3_gen_one_letter_concrete_arg.v')
    os.write_file(one_letter_src, '
struct A {
    value int
}

struct Box[T] {
    value T
}

fn main() {
    b := Box[A]{
        value: A{
            value: 3
        }
    }
    _ := b
}
') or {
        panic(err)
    }
    one_letter_bin := os.join_path(os.temp_dir(), 'v3_gen_one_letter_concrete_arg')
    one_letter_compile := os.execute('${v3_bin} ${one_letter_src} -b c -o ${one_letter_bin}')
    assert !one_letter_compile.output.contains('unsupported generic'), one_letter_compile.output
    assert !one_letter_compile.output.contains('type checker found'), one_letter_compile.output
    one_letter_c := os.read_file(one_letter_bin + '.c') or { '' }
    assert one_letter_c.contains('struct Box_A'), one_letter_c

    // transitive generic calls: outer[T] calls id[T]
    run_generic_ok(v3_bin, 'run_transitive', '
fn id[T](x T) T {
    return x
}
fn outer[T](x T) T {
    return id(x)
}
fn main() {
    println(outer(42))
}
',
        '42')

    // multi-param generic
    run_generic_ok(v3_bin, 'run_multi_param', '
fn first[A, B](a A, b B) A {
    return a
}
fn main() {
    println(first(99, "ignored"))
}
',
        '99')

    // multi-param generic struct fields
    run_generic_ok(v3_bin, 'run_multi_param_struct_fields', '
struct Pair[X, Y] {
    left X
    right Y
}
fn main() {
    p := Pair[int, string]{left: 1, right: "ok"}
    println(p.right)
}
',
        'ok')

    // infer from array element type
    run_generic_ok(v3_bin, 'run_array_infer', '
fn length[T](xs []T) int {
    return xs.len
}
fn main() {
    println(length([1, 2, 3]))
}
',
        '3')

    selector_convert_out := run_generic_exec(v3_bin, 'selector_method_arg_infer', '
struct Box[T] {
    value T
}

fn (b Box[T]) convert[U](value U) U {
    return value
}

fn main() {
    b := Box[int]{value: 1}
    println(b.convert("ok"))
}
')
    assert selector_convert_out == 'ok'
}