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')

fn build_v3_with(name string, flags string) string {
	v3_bin := os.join_path(os.temp_dir(), name)
	build :=
		os.execute('${vexe} -gc none ${flags} -path "${vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${v3_src}')
	assert build.exit_code == 0, build.output
	return v3_bin
}

fn build_v3() string {
	return build_v3_with('v3_test_file_harness_test', '')
}

fn write_source(name string, suffix string, src string) string {
	src_path := os.join_path(os.temp_dir(), 'v3_${name}${suffix}')
	os.write_file(src_path, src) or { panic(err) }
	return src_path
}

fn write_project(name string, files map[string]string) string {
	root := os.join_path(os.temp_dir(), 'v3_${name}')
	os.rmdir_all(root) or {}
	for rel, src in files {
		path := os.join_path(root, rel)
		os.mkdir_all(os.dir(path)) or { panic(err) }
		os.write_file(path, src) or { panic(err) }
	}
	return root
}

fn gen_c(v3_bin string, name string, suffix string, src string) string {
	return gen_c_flags(v3_bin, name, suffix, src, '')
}

fn gen_c_flags(v3_bin string, name string, suffix string, src string, flags string) string {
	src_path := write_source(name, suffix, src)
	c_path := os.join_path(os.temp_dir(), 'v3_${name}.c')
	os.rm(c_path) or {}
	compile := os.execute('${v3_bin} ${flags} ${src_path} -b c -o ${c_path}')
	assert compile.exit_code == 0, '${name}: C output failed: ${compile.output}'
	assert os.exists(c_path), '${name}: missing generated C file ${c_path}'
	return os.read_file(c_path) or { panic(err) }
}

fn compile_and_run(v3_bin string, name string, suffix string, src string) os.Result {
	return compile_and_run_flags(v3_bin, name, suffix, src, '')
}

fn compile_and_run_flags(v3_bin string, name string, suffix string, src string, flags string) os.Result {
	src_path := write_source(name, suffix, src)
	bin_path := os.join_path(os.temp_dir(), 'v3_${name}')
	compile := os.execute('${v3_bin} ${flags} ${src_path} -b c -o ${bin_path}')
	assert compile.exit_code == 0, '${name}: compile failed: ${compile.output}'
	assert !compile.output.contains("undefined reference to `main'"), compile.output
	return os.execute(bin_path)
}

fn compile_project_and_run(v3_bin string, name string, files map[string]string) (os.Result, string) {
	root := write_project(name, files)
	return compile_project_root_and_run(v3_bin, name, root)
}

fn compile_project_root_and_run(v3_bin string, name string, root string) (os.Result, string) {
	bin_path := os.join_path(root, 'out')
	compile := os.execute('${v3_bin} ${root} -b c -o ${bin_path}')
	assert compile.exit_code == 0, '${name}: compile failed: ${compile.output}'
	run := os.execute(bin_path)
	c_code := os.read_file(bin_path + '.c') or { panic(err) }
	return run, c_code
}

fn compile_expect_failure(v3_bin string, name string, suffix string, src string) os.Result {
	return compile_expect_failure_flags(v3_bin, name, suffix, src, '')
}

fn compile_expect_failure_flags(v3_bin string, name string, suffix string, src string, flags string) os.Result {
	src_path := write_source(name, suffix, src)
	bin_path := os.join_path(os.temp_dir(), 'v3_${name}')
	c_path := bin_path + '.c'
	os.rm(c_path) or {}
	compile := os.execute('${v3_bin} ${flags} ${src_path} -b c -o ${bin_path}')
	assert compile.exit_code != 0, '${name}: compile unexpectedly succeeded: ${compile.output}'
	assert !os.exists(c_path), '${name}: generated C despite harness input failure'
	return compile
}

fn test_v3_generates_minimal_test_file_harness() {
	v3_bin := build_v3()
	order_src := "fn test_one() {
	println('one')
}

fn test_two() {
	println('two')
}
"
	order_c := gen_c(v3_bin, 'harness_order', '_test.c.v', order_src)
	assert order_c.contains('int main('), order_c
	one_idx := order_c.index('test_one();') or { -1 }
	two_idx := order_c.index('test_two();') or { -1 }
	assert one_idx >= 0, order_c
	assert two_idx > one_idx, order_c
	order_run := compile_and_run(v3_bin, 'harness_order_run', '_test.c.v', order_src)
	assert order_run.exit_code == 0, order_run.output
	assert order_run.output.trim_space() == 'one\ntwo'

	parallel_v3_bin := build_v3_with('v3_test_file_harness_parallel_test', '-d parallel')
	parallel_c := gen_c(parallel_v3_bin, 'harness_parallel_order', '_test.c.v', order_src)
	assert parallel_c.contains('int main('), parallel_c
	assert parallel_c.contains('test_one();'), parallel_c
	assert parallel_c.contains('test_two();'), parallel_c
	parallel_run := compile_and_run(parallel_v3_bin, 'harness_parallel_order_run', '_test.c.v',
		order_src)
	assert parallel_run.exit_code == 0, parallel_run.output
	assert parallel_run.output.trim_space() == 'one\ntwo'

	hooks_src := "fn testsuite_begin() {
	println('begin')
}

fn testsuite_end() {
	println('end')
}

fn before_each() {
	println('before')
}

fn after_each() {
	println('after')
}

fn test_option() ? {
	println('option')
	return
}

fn test_result() ! {
	println('result')
	return
}
"
	hooks_run := compile_and_run(v3_bin, 'harness_hooks', '_test.v', hooks_src)
	assert hooks_run.exit_code == 0, hooks_run.output
	assert hooks_run.output.trim_space() == 'begin\nbefore\noption\nafter\nbefore\nresult\nafter\nend'

	result_fail := compile_and_run(v3_bin, 'harness_result_fail', '_test.v', "fn test_fail() ! {
	return error('bad')
}
")
	assert result_fail.exit_code != 0
	assert result_fail.output.contains('test failed: test_fail')

	result_fail_cleanup := compile_and_run(v3_bin, 'harness_result_fail_cleanup', '_test.v', "fn testsuite_end() {
	println('end')
}

fn after_each() {
	println('after')
}

fn test_fail() ! {
	return error('bad')
}
")
	assert result_fail_cleanup.exit_code != 0
	assert result_fail_cleanup.output.contains('test failed: test_fail')
	assert result_fail_cleanup.output.contains('after')
	assert result_fail_cleanup.output.contains('end')

	option_fail := compile_and_run(v3_bin, 'harness_option_fail', '_test.v', 'fn test_fail() ? {
	return none
}
')
	assert option_fail.exit_code != 0
	assert option_fail.output.contains('test failed: test_fail')

	option_fail_cleanup := compile_and_run(v3_bin, 'harness_option_fail_cleanup', '_test.v', "fn testsuite_end() {
	println('end')
}

fn after_each() {
	println('after')
}

fn test_fail() ? {
	return none
}
")
	assert option_fail_cleanup.exit_code != 0
	assert option_fail_cleanup.output.contains('test failed: test_fail')
	assert option_fail_cleanup.output.contains('after')
	assert option_fail_cleanup.output.contains('end')

	assert_fail := compile_and_run(v3_bin, 'harness_assert_fail', '_test.v', 'fn test_fail() {
	assert false
}
')
	assert assert_fail.exit_code != 0
	assert assert_fail.output.contains('assert failed')

	invalid_param := compile_expect_failure(v3_bin, 'harness_invalid_param', '_test.v', 'fn test_bad(i int) {
}
')
	assert invalid_param.output.contains('invalid test signature'), invalid_param.output

	generic_test := compile_expect_failure(v3_bin, 'harness_generic_test', '_test.v', 'fn test_generic[T]() {
}
')
	assert generic_test.output.contains('invalid test signature'), generic_test.output

	invalid_return := compile_expect_failure(v3_bin, 'harness_invalid_return', '_test.v', 'fn test_bad() int {
	return 1
}
')
	assert invalid_return.output.contains('invalid test signature'), invalid_return.output

	non_main := compile_expect_failure(v3_bin, 'harness_non_main_module', '_test.c.v', 'module sample

fn test_one() {
}
')
	assert non_main.output.contains('no runnable tests'), non_main.output

	result_hook := compile_expect_failure(v3_bin, 'harness_result_hook', '_test.v', 'fn before_each() ! {
	return
}

fn test_one() {
}
')
	assert result_hook.output.contains('invalid test hook signature'), result_hook.output

	generic_hook := compile_expect_failure(v3_bin, 'harness_generic_hook', '_test.v', 'fn before_each[T]() {
}

fn test_one() {
}
')
	assert generic_hook.output.contains('invalid test hook signature'), generic_hook.output

	option_hook := compile_expect_failure(v3_bin, 'harness_option_hook', '_test.v', 'fn after_each() ? {
	return
}

fn test_one() {
}
')
	assert option_hook.output.contains('invalid test hook signature'), option_hook.output

	ordinary_c := gen_c(v3_bin, 'harness_plain_file', '.v', "fn test_lonely() {
	println('lonely')
}
")
	assert !ordinary_c.contains('int main('), ordinary_c
	assert !ordinary_c.contains('test_lonely();'), ordinary_c
}

fn test_v3_test_file_harness_rejects_top_level_stmt() {
	v3_bin := build_v3()
	src := "println('top')

fn test_one() {
	println('test')
}
"
	invalid := compile_expect_failure(v3_bin, 'harness_top_level_and_test', '_test.v', src)
	assert invalid.output.contains('executable top-level statements are not supported in test files'), invalid.output
}

fn test_v3_test_file_harness_owns_entrypoint_over_user_main() {
	v3_bin := build_v3()
	src := "fn main() {
	println('user-main')
}

fn test_one() {
	println('test')
}
"
	c_code := gen_c(v3_bin, 'harness_user_main', '_test.v', src)
	assert c_code.count('int main(') == 1, c_code
	assert c_code.contains('test_one();'), c_code
	run := compile_and_run(v3_bin, 'harness_user_main_run', '_test.v', src)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'test'
}

fn test_v3_test_file_harness_keeps_user_main_callable() {
	v3_bin := build_v3()
	src := "fn main() {
	println('user-main')
}

fn test_call_main() {
	main()
}
"
	c_code := gen_c(v3_bin, 'harness_user_main_callable', '_test.v', src)
	assert c_code.count('int main(') == 1, c_code
	assert c_code.contains('main__user_main'), c_code
	assert c_code.contains('main__user_main();'), c_code
	assert c_code.contains('test_call_main();'), c_code
	run := compile_and_run(v3_bin, 'harness_user_main_callable_run', '_test.v', src)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'user-main'
}

fn test_v3_test_file_harness_forward_declares_user_main() {
	v3_bin := build_v3()
	src := "fn test_call_main() {
	main()
}

fn main() {
	println('late-main')
}
"
	c_code := gen_c(v3_bin, 'harness_user_main_forward', '_test.v', src)
	assert c_code.count('int main(') == 1, c_code
	proto_idx := c_code.index('void main__user_main(void);') or { -1 }
	test_idx := c_code.index('void test_call_main(void) {') or { -1 }
	assert proto_idx >= 0, c_code
	assert test_idx > proto_idx, c_code
	assert c_code.contains('main__user_main();'), c_code
	run := compile_and_run(v3_bin, 'harness_user_main_forward_run', '_test.v', src)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'late-main'
}

fn test_v3_test_file_harness_renames_user_main_without_collision() {
	v3_bin := build_v3()
	src := "fn main__user_main() {
	println('collision')
}

fn main() {
	println('user-main')
}

fn test_call_both() {
	main__user_main()
	main()
}
"
	c_code := gen_c(v3_bin, 'harness_user_main_collision', '_test.v', src)
	assert c_code.count('int main(') == 1, c_code
	assert c_code.contains('void main__user_main('), c_code
	assert c_code.contains('void main__user_main_1('), c_code
	assert c_code.contains('main__user_main();'), c_code
	assert c_code.contains('main__user_main_1();'), c_code
	run := compile_and_run(v3_bin, 'harness_user_main_collision_run', '_test.v', src)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'collision\nuser-main'
}

fn test_v3_test_file_harness_renames_user_main_fn_value() {
	v3_bin := build_v3()
	src := "fn main() {
	println('user-main')
}

fn test_fn_value_main() {
	f := main
	f()
}
"
	c_code := gen_c(v3_bin, 'harness_user_main_fn_value', '_test.v', src)
	assert c_code.count('int main(') == 1, c_code
	assert c_code.contains('main__user_main'), c_code
	assert c_code.contains('test_fn_value_main();'), c_code
	assert !c_code.contains('= main;'), c_code
	run := compile_and_run(v3_bin, 'harness_user_main_fn_value_run', '_test.v', src)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'user-main'
}

fn test_v3_test_file_harness_renames_user_main_fn_arg() {
	v3_bin := build_v3()
	src := "fn takes(cb fn ()) {
	cb()
}

fn main() {
	println('user-main')
}

fn test_fn_arg_main() {
	takes(main)
}
"
	c_code := gen_c(v3_bin, 'harness_user_main_fn_arg', '_test.v', src)
	assert c_code.count('int main(') == 1, c_code
	assert c_code.contains('takes(main__user_main);'), c_code
	assert !c_code.contains('takes(main);'), c_code
	run := compile_and_run(v3_bin, 'harness_user_main_fn_arg_run', '_test.v', src)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'user-main'
}

fn test_v3_test_file_harness_does_not_rename_shadowed_main_fn_value_call() {
	v3_bin := build_v3()
	src := "fn call_shadowed(main fn ()) {
	main()
}

fn local_cb() {
	println('local-cb')
}

fn main() {
	println('user-main')
}

fn test_shadowed_main() {
	call_shadowed(local_cb)
}
"
	c_code := gen_c(v3_bin, 'harness_shadowed_main_fn_value_call', '_test.v', src)
	assert c_code.count('int main(') == 1, c_code
	assert c_code.contains('main();'), c_code
	assert !c_code.contains('main__user_main();'), c_code
	run := compile_and_run(v3_bin, 'harness_shadowed_main_fn_value_call_run', '_test.v', src)
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'local-cb'
}

fn test_v3_test_file_harness_finds_top_level_comptime_block_tests() {
	v3_bin := build_v3()
	src := "$if v3_nested_harness ? {
	fn before_each() {
		println('before')
	}

	fn test_nested() {
		println('nested')
	}
}
"
	c_code := gen_c_flags(v3_bin, 'harness_nested_block', '_test.v', src, '-d v3_nested_harness')
	assert c_code.contains('before_each();'), c_code
	assert c_code.contains('test_nested();'), c_code
	run := compile_and_run_flags(v3_bin, 'harness_nested_block_run', '_test.v', src,
		'-d v3_nested_harness')
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'before\nnested'

	invalid := compile_expect_failure_flags(v3_bin, 'harness_nested_invalid', '_test.v', '$if v3_nested_harness ? {
	fn test_bad(i int) {
	}
}
',
		'-d v3_nested_harness')
	assert invalid.output.contains('invalid test signature'), invalid.output

	invalid_generic := compile_expect_failure_flags(v3_bin, 'harness_nested_generic_invalid',
		'_test.v', '$if v3_nested_harness ? {
	fn before_each[T]() {
	}

	fn test_nested[T]() {
	}
}
',
		'-d v3_nested_harness')
	assert invalid_generic.output.contains('invalid test hook signature'), invalid_generic.output
	assert invalid_generic.output.contains('invalid test signature'), invalid_generic.output
}

fn test_v3_top_level_main_preserves_file_import_alias_context() {
	v3_bin := build_v3()
	run, c_code := compile_project_and_run(v3_bin, 'harness_file_alias_context', {
		'v.mod':      'Module { name: "alias_context" }
'
		'a/a.v':      'module a

pub fn value() int {
	return 11
}
'
		'b/b.v':      'module b

pub fn value() int {
	return 22
}
'
		'aa_alias.v': 'module main

import a as m

a_value := m.value()
println(int_str(a_value))
'
		'zz_alias.v': 'module main

import b as m

b_value := m.value()
println(int_str(b_value))
'
	})
	assert run.exit_code == 0, run.output
	lines := run.output.trim_space().split_into_lines()
	assert lines.len == 2, run.output
	assert '11' in lines, run.output
	assert '22' in lines, run.output
	assert c_code.contains('a__value()'), c_code
	assert c_code.contains('b__value()'), c_code
}

fn test_v3_top_level_match_lowers_before_cgen_main() {
	v3_bin := build_v3()
	run := compile_and_run(v3_bin, 'harness_top_level_match', '.v', "x := match 2 {
	2 {
		7
	}
	else {
		3
	}
}
println(int_str(x))
match 2 {
	2 {
		println('two')
	}
	else {}
}
")
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == '7\ntwo'
}

fn test_v3_top_level_defer_runs_after_synthetic_main_body() {
	v3_bin := build_v3()
	run := compile_and_run(v3_bin, 'harness_top_level_defer', '.v', "fn deferred_msg() string {
	return 'deferred'
}

defer {
	println(deferred_msg())
}

println('body')
")
	assert run.exit_code == 0, run.output
	assert run.output.trim_space() == 'body\ndeferred'
}