// vtest build: macos
module eval

import os
import v2.ast
import v2.parser
import v2.pref
import v2.token
import time

const eval_backend_timeout_ms = 60_000
const eval_backend_poll_ms = 50
const eval_backend_term_grace_ms = 1_000

fn testsuite_begin() {
    skip_test('v2 eval tests are temporarily disabled')
}

fn eval_backend_tmp_dir() string {
    return os.join_path(os.temp_dir(), 'v2_eval_integration_${os.getpid()}')
}

fn ensure_eval_backend_runner(vexe string) !string {
    tmp_dir := eval_backend_tmp_dir()
    os.mkdir_all(tmp_dir)!
    v2_exe := os.join_path(tmp_dir, 'v2_eval_runner')
    if os.exists(v2_exe) {
        return v2_exe
    }
    vroot := os.dir(vexe)
    build_res := os.execute('${os.quoted_path(vexe)} -o ${os.quoted_path(v2_exe)} ${os.quoted_path(os.join_path(vroot,
        'cmd', 'v2', 'v2.v'))}')
    if build_res.exit_code != 0 {
        return error(build_res.output)
    }
    return v2_exe
}

fn run_eval_backend(code string) !os.Result {
    return run_eval_backend_with_args(code, []string{})
}

fn run_eval_backend_with_args(code string, extra_args []string) !os.Result {
    vexe := os.getenv('VEXE')
    if vexe == '' {
        return error('VEXE is not set')
    }
    tmp_dir := eval_backend_tmp_dir()
    os.mkdir_all(tmp_dir)!
    tmp_file := os.join_path(tmp_dir, 'sample_${time.now().unix_micro()}.v')
    os.write_file(tmp_file, code)!
    defer {
        os.rm(tmp_file) or {}
    }
    v2_exe := ensure_eval_backend_runner(vexe)!

    mut p := os.new_process(v2_exe)
    mut args := ['-backend', 'eval', tmp_file]
    if extra_args.len > 0 {
        args << '--'
        args << extra_args
    }
    p.set_args(args)
    p.set_redirect_stdio()
    p.run()
    defer {
        p.close()
    }

    mut waited_ms := 0
    for p.is_alive() && waited_ms < eval_backend_timeout_ms {
        time.sleep(eval_backend_poll_ms * time.millisecond)
        waited_ms += eval_backend_poll_ms
    }
    if p.is_alive() {
        p.signal_term()
        mut grace_ms := 0
        for p.is_alive() && grace_ms < eval_backend_term_grace_ms {
            time.sleep(eval_backend_poll_ms * time.millisecond)
            grace_ms += eval_backend_poll_ms
        }
        if p.is_alive() {
            p.signal_kill()
            return error('eval backend timed out after ${eval_backend_timeout_ms}ms')
        }
    }
    p.wait()
    stdout := p.stdout_slurp()
    stderr := p.stderr_slurp()
    return os.Result{
        exit_code: p.code
        output:    stdout + stderr
    }
}

fn test_eval_function_call_and_for_range() {
    mut e := create()
    e.run_text('
fn sum(n int) int {
    mut acc := 0
    for i in 0 .. n {
        acc += i
    }
    return acc
}

fn main() {
    println(sum(5))
}
') or {
        panic(err)
    }
    assert e.stdout() == '10\n'
}

fn test_eval_if_expr_value() {
    mut e := create()
    e.run_text('
fn main() {
    x := if 3 > 2 {
        41
    } else {
        0
    }
    println(x + 1)
}
') or {
        panic(err)
    }
    assert e.stdout() == '42\n'
}

fn test_eval_array_append_and_string_interpolation() {
    mut e := create()
    e.run_text('
fn main() {
    mut arr := []int{}
    arr << 7
    arr << 9
    println("\${arr[0]}:\${arr[1]}:\${arr.len}")
}
') or {
        panic(err)
    }
    assert e.stdout() == '7:9:2\n'
}

fn test_eval_transformed_array_append_and_string_interpolation() {
    res := run_eval_backend('
fn main() {
    mut arr := []int{}
    arr << 7
    arr << 9
    println("\${arr[0]}:\${arr[1]}:\${arr.len}")
}
') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('7:9:2\n')
}

fn test_eval_runtime_args_follow_separator() {
    res := run_eval_backend_with_args('
import os

fn main() {
    println(os.args.join("|"))
}
', [
        'alpha',
        'beta',
    ]) or { panic(err) }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('|alpha|beta')
}

fn test_eval_transformed_nested_array_clone() {
    res := run_eval_backend("
fn main() {
    mut a := [[1, 2], [3]]
    mut b := a.clone()
    b[0] << 9
    println('\${a[0].len}:\${b[0].len}')
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('2:3\n')
}

fn test_eval_transformed_array_append_many() {
    res := run_eval_backend("
fn main() {
    mut items := [1]
    items << [2, 3]
    println('\${items[0]}:\${items[1]}:\${items[2]}:\${items.len}')
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('1:2:3:3\n')
}

fn test_eval_transformed_types_init_universe() {
    res := run_eval_backend("
import v2.types

fn main() {
    _ = types.init_universe()
    println('ok')
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('ok\n')
}

fn test_eval_transformed_types_lookup_parent_typ() {
    res := run_eval_backend("
import v2.types

fn main() {
    u := types.init_universe()
    if obj := u.lookup_parent('string', 0) {
        _ = obj.typ()
        println('ok')
    } else {
        println('missing')
    }
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('ok\n')
}

fn test_eval_transformed_map_if_guard_with_nested_sumtype() {
    res := run_eval_backend("
import v2.types

fn lookup(m map[string]types.Object, key string) ?types.Object {
    if obj := m[key] {
        return obj
    }
    return none
}

fn main() {
    mut m := map[string]types.Object{}
    m['x'] = types.Object(types.Type(types.string_))
    if obj := lookup(m, 'x') {
        _ = obj.typ()
        println('ok')
    } else {
        println('missing')
    }
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('ok\n')
}

fn test_eval_transformed_map_builtin_fast_paths() {
    res := run_eval_backend("
fn main() {
    mut m := map[string]int{}
    m['a'] = 1
    m['b'] += 2
    a_val := m['a']
    b_val := m['b']
    has_a := 'a' in m
    println('\${a_val}:\${b_val}:\${m.keys().len}:\${m.values().len}:\${has_a}')
    m.delete('a')
    mut cloned := m.clone()
    mut moved := cloned.move()
    cloned.clear()
    has_a_after_delete := 'a' in m
    has_b_in_moved := 'b' in moved
    moved_b := moved['b'] or { 0 }
    println('\${has_a_after_delete}:\${has_b_in_moved}:\${cloned.len}:\${moved_b}')
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('1:2:2:2:true\n')
    assert res.output.contains('false:true:0:2\n')
}

fn test_eval_transformed_os_execute() {
    res := run_eval_backend("
import os

fn main() {
    cmd := if os.user_os() == 'windows' { 'cmd /c echo ok' } else { 'printf ok' }
    result := os.execute(cmd)
    println('\${result.exit_code}:\${result.output}')
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('0:ok')
}

fn test_eval_transformed_smartcast_assignment() {
    res := run_eval_backend('
struct Foo {
mut:
    n int
}

struct Bar {}

type W = Bar | Foo

fn main() {
    mut w := W(Foo{n: 1})
    if w is Foo {
        w.n = 2
    }
    if w is Foo {
        println(w.n)
    }
}
    ') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('2\n')
}

fn test_eval_transformed_ast_expr_pos() {
    res := run_eval_backend("
import v2.ast

fn main() {
    expr := ast.Expr(ast.PrefixExpr{})
    _ = expr.pos()
    println('ok')
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('ok\n')
}

fn test_eval_array_has_named_struct_field() {
    e := create()
    attrs := ArrayValue{
        values: [
            Value(StructValue{
                type_name: 'Attr'
                fields:    {
                    'name': Value('flag')
                }
            }),
        ]
    }
    assert e.array_has(attrs, 'flag')
    assert !e.array_has(attrs, 'other')
}

fn test_eval_sumtype_tag_from_type_value_uses_registered_type_kind() {
    mut prefs := pref.new_preferences()
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(&prefs)
    type_files :=
        os.walk_ext(os.join_path(@VMODROOT, 'vlib', 'v2', 'types'), '.v').filter(!it.ends_with('_test.v'))
    dummy_main := os.join_path(os.temp_dir(), 'v2_eval_dummy_main_${os.getpid()}.v')
    os.write_file(dummy_main, 'module main\nfn main() {}\n') or { panic(err) }
    defer {
        os.rm(dummy_main) or {}
    }
    mut files_to_parse := type_files.clone()
    files_to_parse << dummy_main
    files := par.parse_files(files_to_parse, mut file_set)
    mut e := create()
    e.register_files(files) or { panic(err) }
    info := e.sum_type_info('types.Type') or { panic('missing types.Type sumtype info') }
    struct_tag := e.lookup_sumtype_variant_tag(info, 'Struct') or { panic('missing Struct tag') }
    alias_tag := e.lookup_sumtype_variant_tag(info, 'Alias') or { panic('missing Alias tag') }
    struct_value_tag := e.sumtype_tag_from_value(info, TypeValue{
        name: 'types.ObjectCommon'
    }) or { panic('missing struct kind tag') }
    alias_value_tag := e.sumtype_tag_from_value(info, TypeValue{
        name: 'voidptr'
    }) or { panic('missing alias kind tag') }
    assert struct_value_tag == struct_tag
    assert alias_value_tag == alias_tag
}

fn test_eval_type_sum_data_is_nil() {
    mut prefs := pref.new_preferences()
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(&prefs)
    type_files :=
        os.walk_ext(os.join_path(@VMODROOT, 'vlib', 'v2', 'types'), '.v').filter(!it.ends_with('_test.v'))
    dummy_main := os.join_path(os.temp_dir(), 'v2_eval_dummy_main_${os.getpid()}.v')
    os.write_file(dummy_main, 'module main\nfn main() {}\n') or { panic(err) }
    defer {
        os.rm(dummy_main) or {}
    }
    mut files_to_parse := type_files.clone()
    files_to_parse << dummy_main
    files := par.parse_files(files_to_parse, mut file_set)
    mut e := create()
    e.register_files(files) or { panic(err) }
    assert e.type_sum_data_is_nil(e.zero_struct_value('types.Type'))
    assert !e.type_sum_data_is_nil(TypeValue{
        name: 'types.ObjectCommon'
    })
}

fn test_eval_zero_value_for_sumtype_data_field() {
    mut prefs := pref.new_preferences()
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(&prefs)
    ast_files :=
        os.walk_ext(os.join_path(@VMODROOT, 'vlib', 'v2', 'ast'), '.v').filter(!it.ends_with('_test.v'))
    dummy_main := os.join_path(os.temp_dir(), 'v2_eval_dummy_main_${os.getpid()}.v')
    os.write_file(dummy_main, 'module main\nfn main() {}\n') or { panic(err) }
    defer {
        os.rm(dummy_main) or {}
    }
    mut files_to_parse := ast_files.clone()
    files_to_parse << dummy_main
    files := par.parse_files(files_to_parse, mut file_set)
    mut e := create()
    e.register_files(files) or { panic(err) }
    value := e.zero_value_for_sumtype_data_field('ast.Expr._data', '_ArrayInitExpr') or {
        panic('missing sumtype data field zero value')
    }
    assert value is StructValue
    assert (value as StructValue).type_name == 'ast.ArrayInitExpr'
}

fn test_eval_selector_on_sumtype_data_void_field_returns_zero_value() {
    mut prefs := pref.new_preferences()
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(&prefs)
    ast_files :=
        os.walk_ext(os.join_path(@VMODROOT, 'vlib', 'v2', 'ast'), '.v').filter(!it.ends_with('_test.v'))
    dummy_main := os.join_path(os.temp_dir(), 'v2_eval_dummy_main_${os.getpid()}.v')
    os.write_file(dummy_main, 'module main\nfn main() {}\n') or { panic(err) }
    defer {
        os.rm(dummy_main) or {}
    }
    mut files_to_parse := ast_files.clone()
    files_to_parse << dummy_main
    files := par.parse_files(files_to_parse, mut file_set)
    mut e := create()
    e.register_files(files) or { panic(err) }
    e.open_scope()
    defer {
        e.close_scope() or { panic(err) }
    }
    e.declare_var('data', StructValue{
        type_name: 'ast.Expr._data'
        fields:    {
            '_ArrayInitExpr': Value(void_value())
        }
    })
    data_ident := ast.Ident{
        name: 'data'
    }
    data_lhs := ast.Expr(data_ident)
    data_rhs := ast.Ident{
        name: '_ArrayInitExpr'
    }
    data_selector := ast.SelectorExpr{
        lhs: data_lhs
        rhs: data_rhs
    }
    value := e.eval_selector_expr(data_selector) or { panic(err) }
    assert value is StructValue
    array_init := value as StructValue
    assert array_init.type_name == 'ast.ArrayInitExpr'
    assert 'exprs' in array_init.fields
    assert array_init.fields['exprs'] or { panic('missing exprs field') } is ArrayValue
}

fn test_eval_selector_on_sumtype_wrapper_variant_field_returns_zero_value() {
    mut prefs := pref.new_preferences()
    mut file_set := token.FileSet.new()
    mut par := parser.Parser.new(&prefs)
    ast_files :=
        os.walk_ext(os.join_path(@VMODROOT, 'vlib', 'v2', 'ast'), '.v').filter(!it.ends_with('_test.v'))
    dummy_main := os.join_path(os.temp_dir(), 'v2_eval_dummy_main_${os.getpid()}.v')
    os.write_file(dummy_main, 'module main\nfn main() {}\n') or { panic(err) }
    defer {
        os.rm(dummy_main) or {}
    }
    mut files_to_parse := ast_files.clone()
    files_to_parse << dummy_main
    files := par.parse_files(files_to_parse, mut file_set)
    mut e := create()
    e.register_files(files) or { panic(err) }
    info := e.sum_type_info('ast.Expr') or { panic('missing ast.Expr sum type info') }
    ident_tag := e.lookup_sumtype_variant_tag(info, 'ast.Ident') or {
        panic('missing ast.Ident sumtype tag')
    }
    expr_value := e.build_sumtype_wrapper('ast.Expr', info, ident_tag, StructValue{
        type_name: 'ast.Ident'
        fields:    {
            'name': Value('')
        }
    })
    e.open_scope()
    defer {
        e.close_scope() or { panic(err) }
    }
    e.declare_var('expr', expr_value)
    expr_ident := ast.Ident{
        name: 'expr'
    }
    expr_lhs := ast.Expr(expr_ident)
    expr_rhs := ast.Ident{
        name: '_ArrayInitExpr'
    }
    expr_selector := ast.SelectorExpr{
        lhs: expr_lhs
        rhs: expr_rhs
    }
    value := e.eval_selector_expr(expr_selector) or { panic(err) }
    assert value is StructValue
    assert (value as StructValue).type_name == 'ast.ArrayInitExpr'
}

fn test_eval_lookup_parent_through_parent_scope() {
    res := run_eval_backend("
import v2.types

fn main() {
    mut parent := types.new_scope(unsafe { nil })
    parent.insert('Error', types.Object(types.Type(types.Struct{name: 'builtin__Error'})))
    mut child := types.new_scope(parent)
    if obj := child.lookup_parent('Error', 0) {
        if obj is types.Type {
            println(obj.name())
        }
    }
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('builtin__Error\n')
}

fn test_eval_flag_enum_defaults() {
    res := run_eval_backend('
@[flag]
enum Properties {
    boolean
    float
    integer
    unsigned
    untyped
}

fn main() {
    println(int(Properties.integer))
}
    ') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('4\n')
}

fn test_eval_option_typed_struct_field() {
    res := run_eval_backend('
import v2.types

fn main() {
    println(types.Type(types.Channel{elem_type: types.int_}).name())
}
    ') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('chan int\n')
}

fn test_eval_transformed_type_name_for_primitive_variants() {
    res := run_eval_backend('
import v2.types

fn main() {
    println(types.Type(types.bool_).name())
    println(types.Type(types.int_).name())
    println(types.Type(types.f64_).name())
    println(types.Type(types.voidptr_).name())
}
    ') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('bool\nint\nf64\nvoidptr\n')
}

fn test_eval_transformed_imported_struct_field_assignment_keeps_declaring_module_type() {
    res := run_eval_backend('
import v2.types

fn main() {
    mut m := types.Map{
        key_type: types.Type(types.int_)
        value_type: types.Type(types.int_)
    }
    m.key_type = types.int_
    println(m.key_type.name())
    println(m.key_type.base_type().name())
}
    ') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('int\nint\n')
}

fn test_eval_transformed_typed_array_index_assignment_keeps_sumtype_wrapper() {
    res := run_eval_backend('
import v2.types

fn main() {
    mut items := []types.Type{len: 1, init: types.Type(types.int_)}
    items[0] = types.int_
    println(items[0].name())
    println(items[0].base_type().name())
}
    ') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('int\nint\n')
}

fn test_eval_transformed_typed_map_assignment_keeps_sumtype_wrapper() {
    res := run_eval_backend("
import v2.types

fn main() {
    mut m := map[string]types.Type{}
    m['x'] = types.int_
    println(m['x'].name())
    println(m['x'].base_type().name())
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('int\nint\n')
}

fn test_eval_transformed_object_module_roundtrip_keeps_wrapper() {
    res := run_eval_backend("
import v2.types

fn id(obj types.Object) types.Object {
    return obj
}

fn main() {
    mut mod_scope := types.new_scope(unsafe { nil })
    mod_scope.insert('File', types.Object(types.Struct{
        name: 'File'
    }))
    obj := types.Object(types.Module{
        name:  'ast'
        scope: mod_scope
    })
    println(obj.type_name())
    println(id(obj).type_name())
    mut arr := []types.Object{}
    arr << obj
    println(arr[0].type_name())
    mut m := map[string]types.Object{}
    m['ast'] = obj
    println(m['ast'].type_name())
    if got := m['ast'] {
        println(got.type_name())
        if got is types.Module {
            println(got.name)
            if file_obj := got.scope.lookup_parent('File', 0) {
                println(file_obj.type_name())
                println(file_obj.typ().name())
            }
        }
    }
}
    ") or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('types.Module\ntypes.Module\ntypes.Module\ntypes.Module\ntypes.Module\n')
    assert res.output.contains('ast\ntypes.Type\nFile\n')
}

fn test_eval_transformed_array_parameter_keeps_array_shape() {
    res := run_eval_backend('
import v2.ast

fn stmt_list(stmts []ast.Stmt) {
    println(stmts.len)
}

fn main() {
    items := []ast.Stmt{}
    stmt_list(items)
}
    ') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('0\n')
}

fn test_eval_transformed_array_first_and_last() {
    res := run_eval_backend('
fn main() {
    items := [1, 2, 3]
    println(items.first())
    println(items.last())
}
    ') or {
        panic(err)
    }
    if res.exit_code != 0 {
        panic(res.output)
    }
    assert res.output.contains('1\n3\n')
}

fn test_eval_prefix_bit_not() {
    mut e := create()
    e.run_text('
fn main() {
    println(~1)
}
') or { panic(err) }
    assert e.stdout() == '-2\n'
}

fn test_eval_token_and_byte_helpers() {
    mut e := create()
    e.run_text("
fn main() {
    for i := 0; i < 2; i++ {
        println(i)
    }
    println(r'raw')
    println(u8(`A`).is_alnum())
    println(u8(`A`).is_capital())
    println(u8(` `).is_space())
}
") or {
        panic(err)
    }
    assert e.stdout() == '0\n1\nraw\ntrue\ntrue\ntrue\n'
}

fn test_eval_string_int_conversion() {
    mut e := create()
    e.run_text("
fn main() {
    println('42'.int())
    println('84'.i64())
}
") or { panic(err) }
    assert e.stdout() == '42\n84\n'
}

@[noreturn]
fn skip_test(reason string) {
    println('skipping test, because ${reason} .')
    exit(0)
}