import os
import v3.parser
import v3.pref
import v3.types

const checker_print_tests_dir = os.dir(@FILE)
const checker_print_v3_dir = os.dir(checker_print_tests_dir)
const checker_print_v3_src = os.join_path(checker_print_v3_dir, 'v3.v')
const checker_print_vexe = @VEXE

// check_print_sources validates check print sources state for v3 tests.
fn check_print_sources(name string, files map[string]string) []types.TypeError {
	root := os.join_path(os.temp_dir(), 'v3_checker_print_${name}')
	if os.exists(root) {
		os.rmdir_all(root) or { panic(err) }
	}
	os.mkdir_all(root) or { panic(err) }
	mut paths := []string{}
	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) }
		paths << path
	}
	prefs := pref.new_preferences()
	mut p := parser.Parser.new(prefs)
	mut a := p.parse_files(paths)
	mut tc := types.TypeChecker.new(a)
	tc.collect(a)
	for path in paths {
		tc.diagnostic_files[path] = true
	}
	tc.diagnose_unknown_calls = true
	tc.check_semantics()
	return tc.errors
}

// build_checker_print_v3_bin builds checker print v3 bin data for v3 tests.
fn build_checker_print_v3_bin(name string) string {
	v3_bin := os.join_path(os.temp_dir(), 'v3_checker_print_${name}')
	build := os.execute('${checker_print_vexe} -o ${v3_bin} ${checker_print_v3_src}')
	assert build.exit_code == 0, build.output
	return v3_bin
}

// test_bare_println_allows_non_string_for_stringify_lowering validates this v3 regression case.
fn test_bare_println_allows_non_string_for_stringify_lowering() {
	errors := check_print_sources('bare_println', {
		'main.v': 'module main

fn println(s string) {}

fn main() {
	println(123)
}
'
	})
	assert errors.len == 0, errors.str()
}

// test_local_println_non_string_param_keeps_declared_arg_type validates this v3 regression case.
fn test_local_println_non_string_param_keeps_declared_arg_type() {
	errors := check_print_sources('local_println_int_param', {
		'main.v': 'module main

fn println(i int) {}

fn main() {
	println("x")
}
'
	})
	assert errors.len == 1, errors.str()
	assert errors[0].msg == 'cannot use `string` as argument 1 to `println`; expected `int`'
}

// test_qualified_println_keeps_declared_arg_type validates this v3 regression case.
fn test_qualified_println_keeps_declared_arg_type() {
	errors := check_print_sources('qualified_println', {
		'main.v':    'module main

import log

fn main() {
	log.println(123)
}
'
		'log/log.v': 'module log

pub fn println(s string) {}
'
	})
	assert errors.len == 1, errors.str()
	assert errors[0].msg == 'cannot use `int` as argument 1 to `log.println`; expected `string`'
}

// test_eprint_bool_compile_uses_stringification validates this v3 regression case.
fn test_eprint_bool_compile_uses_stringification() {
	v3_bin := build_checker_print_v3_bin('eprint_bool')
	src := os.join_path(os.temp_dir(), 'v3_checker_print_eprint_bool.v')
	bin := os.join_path(os.temp_dir(), 'v3_checker_print_eprint_bool')
	os.write_file(src, '
fn main() {
	eprint(true)
}
') or { panic(err) }
	compile := os.execute('${v3_bin} -o ${bin} ${src}')
	assert compile.exit_code == 0, compile.output
}