import os

const mini_calc_vexe = @VEXE
const mini_calc_tests_dir = os.dir(@FILE)
const mini_calc_v3_dir = os.dir(mini_calc_tests_dir)
const mini_calc_vlib_dir = os.dir(mini_calc_v3_dir)
const mini_calc_v3_src = os.join_path(mini_calc_v3_dir, 'v3.v')
const mini_calc_repo_root = os.dir(mini_calc_vlib_dir)

fn mini_calc_build_v3() string {
    v3_bin := os.join_path(os.temp_dir(), 'v3_mini_calc_markused_test_${os.getpid()}')
    os.rm(v3_bin) or {}
    build :=
        os.execute('${mini_calc_vexe} -gc none -path "${mini_calc_vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${mini_calc_v3_src}')
    assert build.exit_code == 0, build.output
    return v3_bin
}

fn mini_calc_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 mini_calc_compile_run(v3_bin string, name string, files map[string]string, main_file string) (string, string) {
    root := os.join_path(os.temp_dir(), 'v3_mini_calc_markused_${name}_${os.getpid()}')
    os.rmdir_all(root) or {}
    mini_calc_write_file(root, 'v.mod', "Module { name: 'mini_calc_markused' }\n")
    for rel, src in files {
        mini_calc_write_file(root, rel, src)
    }
    main_path := os.join_path(root, main_file)
    bin := os.join_path(root, 'out')
    compile := os.execute('${v3_bin} ${main_path} -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 mini_calc_compile_bad(v3_bin string, name string, files map[string]string, main_file string) string {
    root := os.join_path(os.temp_dir(), 'v3_mini_calc_markused_bad_${name}_${os.getpid()}')
    os.rmdir_all(root) or {}
    mini_calc_write_file(root, 'v.mod', "Module { name: 'mini_calc_markused_bad' }\n")
    for rel, src in files {
        mini_calc_write_file(root, rel, src)
    }
    main_path := os.join_path(root, main_file)
    bin := os.join_path(root, 'out')
    compile := os.execute('${v3_bin} ${main_path} -b c -o ${bin}')
    assert compile.exit_code != 0, '${name}: compile unexpectedly succeeded: ${compile.output}'
    return compile.output
}

fn test_top_level_for_local_receiver_roots_recursive_chain_only() {
    v3_bin := mini_calc_build_v3()
    output, generated := mini_calc_compile_run(v3_bin, 'for_top_level_receiver', {
        'main.v': 'module main

struct Parser {}

fn (mut p Parser) expr() !int {
    return p.term()!
}

fn (mut p Parser) term() !int {
    return 8
}

fn (mut p Parser) unused() !int {
    return 99
}

for i := 0; i < 1; i++ {
    mut parser := Parser{}
    result := parser.expr() or { 0 }
    println(int_str(result))
}
'
    }, 'main.v')
    assert output == '8'
    assert generated.contains('Parser__expr('), generated
    assert generated.contains('Parser__term('), generated
    assert !generated.contains('Parser__unused('), generated
}

fn test_top_level_future_local_receiver_is_not_rooted() {
    v3_bin := mini_calc_build_v3()
    output := mini_calc_compile_bad(v3_bin, 'future_local_receiver', {
        'main.v': 'module main

struct Parser {}

fn (mut p Parser) expr() !int {
    return 7
}

result := parser.expr() or { 0 }
mut parser := Parser{}
println(int_str(result))
'
    }, 'main.v')
    assert output.contains('unknown function `parser.expr`') || output.contains('unknown__expr')
        || output.contains('C compilation failed'), output
}

fn test_top_level_same_declaration_receiver_is_not_rooted() {
    v3_bin := mini_calc_build_v3()
    output := mini_calc_compile_bad(v3_bin, 'same_decl_receiver', {
        'main.v': 'module main

struct Parser {}

fn (mut p Parser) expr() !int {
    return 7
}

parser := parser.expr() or { 0 }
println(int_str(parser))
'
    }, 'main.v')
    assert output.contains('unknown function `parser.expr`') || output.contains('unknown__expr')
        || output.contains('C compilation failed'), output
}

fn test_top_level_multi_decl_same_statement_receiver_is_not_rooted() {
    v3_bin := mini_calc_build_v3()
    output := mini_calc_compile_bad(v3_bin, 'multi_decl_same_statement_receiver', {
        'main.v': 'module main

struct Parser {}

fn (mut p Parser) expr() !int {
    return 7
}

parser, result := Parser{}, parser.expr() or { 0 }
_ := parser
println(int_str(result))
'
    }, 'main.v')
    assert output.contains('unknown function `parser.expr`') || output.contains('unknown__expr')
        || output.contains('C compilation failed'), output
}

fn test_top_level_block_and_if_scope_do_not_leak_receiver_type() {
    v3_bin := mini_calc_build_v3()
    output, generated := mini_calc_compile_run(v3_bin, 'block_scope', {
        'main.v': 'module main

struct Parser {}

fn (mut p Parser) expr() !int {
    return 1
}

{
    mut parser := Parser{}
    _ := parser
}
if true {
    mut parser := Parser{}
    _ := parser
}
println("ok")
'
    }, 'main.v')
    assert output == 'ok'
    assert !generated.contains('Parser__expr('), generated
}

fn test_explicit_main_ignores_top_level_receiver_calls() {
    v3_bin := mini_calc_build_v3()
    output, generated := mini_calc_compile_run(v3_bin, 'explicit_main', {
        'main.v': 'module main

struct Parser {}

fn (mut p Parser) expr() !int {
    return p.term()!
}

fn (mut p Parser) term() !int {
    return 7
}

mut parser := Parser{}
_ := parser.expr() or { 0 }

fn main() {
    println("entry")
}
'
    }, 'main.v')
    assert output == 'entry'
    assert !generated.contains('Parser__expr('), generated
    assert !generated.contains('Parser__term('), generated
}

fn test_top_level_local_receiver_does_not_root_imported_homonym() {
    v3_bin := mini_calc_build_v3()
    output, generated := mini_calc_compile_run(v3_bin, 'imported_homonym', {
        'main.v':         'module main

import othermod

struct Parser {}

fn (mut p Parser) expr() !int {
    return 5
}

mut parser := Parser{}
println(int_str(parser.expr() or { 0 }))
println(int_str(othermod.touch()))
'
        'othermod/mod.v': 'module othermod

pub struct Parser {}

pub fn touch() int {
    return 2
}

pub fn (mut p Parser) expr() !int {
    return 100
}
'
    }, 'main.v')
    assert output == '5\n2'
    assert generated.contains('Parser__expr('), generated
    assert !generated.contains('othermod__Parser__expr('), generated
}

fn test_top_level_local_receiver_shadows_module_alias() {
    v3_bin := mini_calc_build_v3()
    output, generated := mini_calc_compile_run(v3_bin, 'local_receiver_alias_shadow', {
        'main.v':          'module main

import parsermod as parser

struct Parser {}

fn (mut p Parser) expr() !int {
    return 12
}

mut parser := Parser{}
println(int_str(parser.expr() or { 0 }))
'
        'parsermod/mod.v': 'module parsermod

pub fn expr() int {
    return 3
}
'
    }, 'main.v')
    assert output == '12'
    assert generated.contains('Parser__expr('), generated
    assert !generated.contains('parsermod__expr('), generated
}

fn test_top_level_import_alias_then_local_receiver_shadow_direct_calls() {
    v3_bin := mini_calc_build_v3()
    output, generated := mini_calc_compile_run(v3_bin, 'import_alias_then_local_receiver_shadow', {
        'main.v':          'module main

import parsermod as parser

struct Parser {}

fn (mut p Parser) expr() !int {
    return 99
}

println(int_str(parser.expr()))
mut parser := Parser{}
println(int_str(parser.expr() or { 0 }))
'
        'parsermod/mod.v': 'module parsermod

pub fn expr() int {
    return 17
}
'
    }, 'main.v')
    assert output == '17\n99'
    assert generated.contains('parsermod__expr('), generated
    assert generated.contains('Parser__expr('), generated
}

fn test_mini_calculator_recursive_descent_compiles_and_runs() {
    v3_bin := mini_calc_build_v3()
    example := os.join_path(mini_calc_repo_root, 'examples', 'mini_calculator_recursive_descent.v')
    bin := os.join_path(os.temp_dir(), 'v3_mini_calculator_recursive_descent_${os.getpid()}')
    compile := os.execute('${v3_bin} ${example} -b c -o ${bin}')
    assert compile.exit_code == 0, compile.output
    run := os.execute("printf '2 * (5-1)\\nexit\\n' | ${bin}")
    assert run.exit_code == 0, run.output
    assert run.output.contains('8'), run.output
    generated := os.read_file(bin + '.c') or { panic(err) }
    assert generated.contains('Parser__expr('), generated
    assert generated.contains('Parser__term('), generated
    assert generated.contains('Parser__factor('), generated
    assert generated.contains('Parser__number('), generated
}