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() string {
	v3_bin := os.join_path(os.temp_dir(), 'v3_operator_result_method_checker_test')
	build :=
		os.execute('${vexe} -gc none -path "${vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${v3_src}')
	assert build.exit_code == 0, build.output
	return v3_bin
}

fn write_clock_project(name string, main_src string) string {
	root := os.join_path(os.temp_dir(), 'v3_operator_result_method_${name}')
	os.rmdir_all(root) or {}
	clock_dir := os.join_path(root, 'clock')
	os.mkdir_all(clock_dir) or { panic(err) }
	os.write_file(os.join_path(root, 'v.mod'), "Module { name: 'operator_result_method' }\n") or {
		panic(err)
	}
	os.write_file(os.join_path(clock_dir, 'clock.v'), 'module clock

pub struct Moment {
	value int
}

pub type Span = i64

pub fn now() Moment {
	return Moment{
		value: 1
	}
}

pub fn (lhs Moment) - (rhs Moment) Span {
	return Span(lhs.value - rhs.value)
}

pub fn (span Span) milliseconds() i64 {
	return i64(span)
}
') or {
		panic(err)
	}
	main_path := os.join_path(root, 'main.v')
	os.write_file(main_path, main_src) or { panic(err) }
	return main_path
}

fn check_to_c(v3_bin string, name string, main_src string) os.Result {
	main_path := write_clock_project(name, main_src)
	c_path := os.join_path(os.temp_dir(), 'v3_operator_result_method_${name}.c')
	os.rm(c_path) or {}
	return os.execute('${v3_bin} ${main_path} -b c -o ${c_path}')
}

fn check_standalone_to_c(v3_bin string, name string, main_src string) os.Result {
	main_path := os.join_path(os.temp_dir(), 'v3_${name}.v')
	os.write_file(main_path, main_src) or { panic(err) }
	c_path := os.join_path(os.temp_dir(), 'v3_${name}.c')
	os.rm(c_path) or {}
	return os.execute('${v3_bin} ${main_path} -b c -o ${c_path}')
}

fn test_operator_result_type_is_used_before_method_resolution() {
	v3_bin := build_v3()
	good := 'module main

import clock

fn main() {
	println((clock.now() - clock.now()).milliseconds())
	println(clock.Span(123000000).milliseconds())
	span := clock.Span(10)
	_ := span.milliseconds()
}
'
	good_res := check_to_c(v3_bin, 'good', good)
	assert good_res.exit_code == 0, good_res.output
	assert !good_res.output.contains('unknown function `milliseconds`'), good_res.output

	time_good := 'module main

import time

fn main() {
	println((time.now() - time.now()).milliseconds())
	println(time.Duration(123000000).milliseconds())
	d := time.Duration(10)
	_ := d.milliseconds()
}
'
	time_res := check_to_c(v3_bin, 'time_good', time_good)
	assert time_res.exit_code == 0, time_res.output
	assert !time_res.output.contains('unknown function `milliseconds`'), time_res.output

	time_standalone := 'module main

import time

fn main() {
	d := time.Duration(10); _ := d.milliseconds()
}
'
	time_standalone_res := check_standalone_to_c(v3_bin, 'probe_time_duration_method_clean',
		time_standalone)
	assert time_standalone_res.exit_code == 0, time_standalone_res.output
	assert !time_standalone_res.output.contains('unknown function d.milliseconds'), time_standalone_res.output

	bad := 'module main

import clock

fn main() {
	println((clock.now() - clock.now()).bogus_method())
}
'
	bad_res := check_to_c(v3_bin, 'bad', bad)
	assert bad_res.exit_code != 0, bad_res.output
	assert bad_res.output.contains('unknown function'), bad_res.output
	assert bad_res.output.contains('bogus_method'), bad_res.output
}