type Any = f64 | int | string

struct Test {}

struct Test2 {}

struct Test3 {}

fn (t Test) test(args ...Any) {
	println('called with ${args}')
}

fn (t Test2) test_str(arg string) {
	println('called with ${arg}')
}

fn (t Test2) test_int(arg int, arg2 int) {
	println('called with ${arg}, ${arg2}')
}

fn (t Test3) test_int(arg int, arg2 int) {
	println('called with ${arg}, ${arg2}')
}

fn foo_any(i Any, k Any, j Any) string {
	return '${i} : ${k} : ${j}'
}

fn foo(i int, k int) string {
	return '${i} : ${k}'
}

fn bar(i f64, k f64, j f64) string {
	return '${i} : ${k} : ${j}'
}

fn baz(s string) string {
	return s
}

fn f_arr(i int, f f64) string {
	return '${i} : ${f}'
}

fn f_var(s string, args ...string) string {
	return '${s} [ ${args.map(it).join(',')} ]'
}

fn varargs[T](args ...T) string {
	assert args.len > 0
	return args.map(it.str()).join(' : ')
}

fn call[T](func_name string, args ...T) string {
	return match func_name {
		'foo' { foo(...args) }
		'bar' { bar(...args) }
		'baz' { baz(...args) }
		'varargs' { varargs(...args) }
		else { '' }
	}
}

fn call_any(func_name string, args ...Any) string {
	return match func_name {
		'foo_any' { foo_any(...args) }
		else { '' }
	}
}

fn comptime_call[T](instance T, method_name string, args ...Any) bool {
	$for method in T.methods {
		if method.name == method_name {
			instance.$method(...args)
			return true
		}
	}
	return false
}

fn comptime_call_vargs[T, R](instance T, method_name string, args ...R) bool {
	$for method in T.methods {
		if method.name == method_name {
			instance.$method(...args)
			return true
		}
	}
	return false
}

fn comptime_call_vargs2[T, R](instance T, method_name string, args ...R) bool {
	$for method in T.methods {
		if method.name == method_name {
			instance.$method(200, ...args)
			return true
		}
	}
	return false
}

fn test_main() {
	assert call('foo', 10, 100) == '10 : 100'
	assert call('bar', 1.1, 1.2, 1.3) == '1.1 : 1.2 : 1.3'
	assert call('baz', 'test') == 'test'
	assert call_any('foo_any', 10, 1.2, 'test') == "Any(10) : Any(1.2) : Any('test')"
	assert call[Any]('varargs', 10, 1.2, 'test') == "Any(10) : Any(1.2) : Any('test')"

	a := []int{len: 2, init: 50}
	assert foo(...a) == '50 : 50'

	b := []f64{len: 3, init: 1.2}
	assert bar(...b) == '1.2 : 1.2 : 1.2'

	mut c := []Any{}
	c << 10
	c << 1.2
	c << 'test'
	assert varargs(...c) == "Any(10) : Any(1.2) : Any('test')"

	var := [0.0]
	assert f_arr(1, ...var) == '1 : 0.0'

	var2 := ['a', 'b', 'c']
	assert f_var('foo', ...var2) == 'foo [ a,b,c ]'
}

fn test_comptime() {
	var := Test{}
	assert comptime_call(var, 'test', 1, 2.3, '')

	var2 := Test2{}
	assert comptime_call_vargs(var2, 'test_int', 1, 100)
	assert comptime_call_vargs(var2, 'test_str', 'foo')

	var3 := Test3{}
	assert comptime_call_vargs2(var3, 'test_int', 100)
}