interface Element {
	method(params ...f64) string
}

struct Foo {}

fn (f &Foo) method(params ...f64) string {
	return params.str()
}

fn test_variadic_array_decompose() {
	mut a := []Element{}
	a << Foo{}

	input := [0.0, 1.0]
	assert a[0].method(...input) == '[0.0, 1.0]'
	assert a[0].method(...[0.0, 1.0]) == '[0.0, 1.0]'
}

fn test_variadic_multiple_args() {
	mut a := []Element{}
	a << Foo{}

	assert a[0].method(0.0, 1.0) == '[0.0, 1.0]'
}

interface Animal {}

struct Cat {}

struct Dog {}

fn test_variadic_interface_fn_arg() {
	c := Cat{}
	d := Dog{}
	check_animals(c, d)
}

// For issue 27326: passing a local variable declared inside a loop to a
// variadic interface parameter caused a `pointer expected` C error, because
// the value was promoted to auto-heap at the use site but not at its
// declaration, producing inconsistent pointer indirection in the generated C.
interface Value {}

fn collect(params ...Value) int {
	return params.len
}

fn test_variadic_interface_arg_declared_in_loop() {
	mut total := 0
	for i := 0; i < 3; i++ {
		id := [u8(1), 2, 3]
		code := 'hello ${i}'
		total += collect(id, code)
	}
	assert total == 6
}

type ValueSum = Cat | Dog

// For issue 27326: a variable smartcast via `if x is T` / `match` resolves to a
// synthetic smartcast scope var, not its real declaration. Promoting that
// synthetic var to auto-heap instead of the declaration must not desync the
// pointer indirection when the value is passed to a variadic interface param.
fn test_variadic_interface_arg_smartcast() {
	mut total := 0
	s := ValueSum(Cat{})
	if s is Cat {
		total += collect(s)
	}
	v := Value(Cat{})
	if v is Cat {
		total += collect(v)
	}
	match v {
		Cat { total += collect(v) }
		else {}
	}

	assert total == 3
}

// For issue 27326: a variable that is both declared in a nested scope (a `for`
// loop body) and smartcast via `if x is T` must still resolve to its real
// nested declaration, not the synthetic smartcast var nor only the function
// scope, otherwise the auto-heap promotion desyncs the pointer indirection.
fn test_variadic_interface_arg_smartcast_in_loop() {
	mut total := 0
	for _ in 0 .. 3 {
		s := ValueSum(Cat{})
		if s is Cat {
			total += collect(s)
		}
	}
	for _ in 0 .. 2 {
		v := Value(Cat{})
		if v is Cat {
			total += collect(v)
		}
	}
	assert total == 5
}

fn maybe_value() ?Cat {
	return Cat{}
}

// For issue 27326: an option value unwrapped via an if-guard or `if x != none`
// and then passed to a variadic interface parameter is auto-heap promoted, so
// its declaration is emitted as an option pointer. The unwrapped `.data` read
// at the call site must use the matching pointer indirection (`->data`);
// previously cgen emitted value-style access and failed C compilation.
fn test_variadic_interface_arg_option_unwrap() {
	mut total := 0
	if x := maybe_value() {
		total += collect(x)
	}
	x := maybe_value()
	if x != none {
		total += collect(x)
	}
	for _ in 0 .. 2 {
		y := maybe_value()
		if y != none {
			total += collect(y)
		}
	}
	assert total == 4
}

fn check_animals(animals ...Animal) {
	assert animals[0] is Cat
	assert animals[1] is Dog
}

// For issue: 16286 passing nothing to a variatic parameter on an interface method gives builder error
interface Bar {
	get(...int) []int
}

struct Baz {}

fn (b Baz) get(n ...int) []int {
	if n.len == 0 {
		return [-1]
	} else {
		return n
	}
}

fn test_empty_args_call_interface_methods() {
	b := Baz{}
	assert b.get() == [-1]

	b_values := Bar(Baz{})
	assert b_values.get(1, 2, 3) == [1, 2, 3]

	b_empty := Bar(Baz{})
	assert b_empty.get() == [-1]
}