import arrays { filter_indexed, flat_map, flat_map_indexed, fold, map_indexed, max }

fn test_decl_assignment() {
	my_var := 12
	c1 := fn [my_var] () int {
		return my_var
	}
	assert c1() == 12
}

fn test_assignment() {
	v1 := 1
	mut c := fn [v1] () int {
		return v1
	}
	v2 := 3
	c = fn [v2] () int {
		return v2
	}
	assert c() == 3
}

fn call_anon_with_3(f fn (int) int) int {
	return f(3)
}

fn test_closure_in_call() {
	my_var := int(12)
	r1 := call_anon_with_3(fn [my_var] (add int) int {
		return my_var + add
	})
	assert r1 == 15
}

fn create_simple_counter() fn () int {
	mut c := -1
	return fn [mut c] () int {
		c++
		return c
	}
}

fn override_stack() {
	// just create some variables to modify the stack
	a := 1
	b := a + 2
	c := b + 3
	d := c + 4
	e := d + 5
	f := e + 6
	g := f + 7
	_ = g
}

fn test_closure_exit_original_scope() {
	mut c := create_simple_counter()
	assert c() == 0
	override_stack()
	assert c() == 1
}

fn test_vars_are_changed() {
	mut my_var := 1
	f1 := fn [mut my_var] (expected int) {
		assert my_var == expected
	}
	f1(1)
	my_var = 3
	f1(1)
	my_var = -1
	f1(1)
}

struct Counter {
mut:
	i u64
}

fn (mut c Counter) incr() {
	c.i++
}

fn (mut c Counter) next() u64 {
	c.incr()
	return c.i
}

fn test_call_methods() {
	mut c := Counter{}
	f1 := fn [mut c] () u64 {
		return c.next()
	}
	assert f1() == 1
	assert f1() == 2
	c.incr()
	assert f1() == 3
}

fn test_call_methods_on_pointer() {
	mut c := &Counter{}
	f1 := fn [mut c] () u64 {
		return c.next()
	}
	assert f1() == 1
	assert f1() == 2
	c.incr()
	assert f1() == 4
}

/*
fn test_methods_as_variables() {
	mut c := Counter{}
	f1 := c.next
	assert f1() == 1
	assert f1() == 2
	c.incr()
	assert f1() == 3
}
*/

/*
fn takes_callback(get fn () u64) u64 {
	return get()
}

fn test_methods_as_callback() {
	mut c := Counter{}
	assert takes_callback(c.next) == 1
}
*/

struct ZeroSize {}

fn test_zero_size_ctx() {
	ctx := ZeroSize{}
	c1 := fn [ctx] () int {
		return 123
	}
	assert c1() == 123
}

/*
fn test_go_call_closure() {
	my_var := 12
	ch := chan int{}
	go fn [my_var, ch] () {
		ch <- my_var
	}()
	assert <-ch == 12
	go fn [ch] (arg int) {
		ch <- arg
	}(15)
	assert <-ch == 15
}
*/

fn test_closures_with_ifstmt() {
	a := 1
	f := fn [a] (x int) int {
		if a > x { return 1 } else { return -1 }
	}
	g := fn [a] () int {
		if true {
			return 1
		}
		return 0
	}
	assert f(0) == 1
	assert g() == 1
}

struct Command {
	a int = 1234
	b int = 2345
	c int = 3456
	d int = 4567
	e int = 5678
}

struct App {}

fn test_larger_closure_parameters() {
	mut app := &App{}
	eprintln('app ptr: ${u64(app)}')
	f := fn [mut app] (cmd Command) u64 {
		p := u64(app)
		println('>>   p: ${p}')
		println('>> cmd: ${cmd}')
		assert cmd.a == 1234
		assert cmd.b == 2345
		assert cmd.c == 3456
		assert cmd.d == 4567
		assert cmd.e == 5678
		return p
	}
	cmd := Command{}
	res := f(cmd)
	println('> res: ${res} | sizeof Command: ${sizeof(Command)}')
	assert res == u64(app)
}

fn test_closure_in_for_in_loop() {
	a := [2, 4, 6, 9]
	for v in a {
		func := fn [v] (msg string) string {
			return '${msg}: ${v}'
		}
		res := func('hello')
		assert res == 'hello: ${v}'
		// dump(res)
	}
}

struct ClosureFilterProduct {
mut:
	cross_sell_skus []string
}

fn test_filter_indexed_closure_capture_of_for_mut_value() {
	mut products := [ClosureFilterProduct{
		cross_sell_skus: ['sku-a', 'sku-b']
	}]
	for mut product in products {
		product.cross_sell_skus = filter_indexed[string](product.cross_sell_skus, fn [products, product] (idx int, css string) bool {
			product_snapshot := '${product}'
			products_snapshot := '${products}'
			return idx == 0 && css == 'sku-a' && product_snapshot.len > 0
				&& products_snapshot.len > 0
		})
	}
	assert products[0].cross_sell_skus == ['sku-a']
}

fn ret_two() (int, int) {
	return 2, 5
}

fn test_closure_over_variable_that_is_returned_from_a_multi_value_function() {
	one, two := ret_two()
	a := fn [one] () {
		println(one)
	}
	a()
	println(two)
}

fn test_cross_var_assign_without_inherited() {
	f := fn () {
		mut left := 1
		mut right := 2
		left, right = right, left
		assert left == 2 && right == 1
	}
	f()
}

fn test_cross_var_assign_with_inherited() {
	mut left := 1
	mut right := 2
	f := fn [mut left, mut right] () {
		left, right = right, left
		assert left == 2 && right == 1
	}
	f()
}

// for issue 20498
// test array / string / map as closure params with -autofree
fn get_func_that_contains_closure() fn () {
	arr := [1, 2, 3]
	str := '${'a'}bcabc' // alloc on heap
	m := {
		'key1': 'abcabc'
		'key2': 'abcabc'
	}
	return fn [arr, str, m] () {
		assert arr == [1, 2, 3]
		assert str == 'abcabc'
		assert m == {
			'key1': 'abcabc'
			'key2': 'abcabc'
		}
	}
}

fn test_array_string_and_map_as_closure_params_with_autofree() {
	func := get_func_that_contains_closure()
	func()
	assert true
}

// for issue 20208
// phenomenon: cgen fails when the closure arg is auto_heap and is not reference.
@[heap]
struct Abc {
	value int
}

@[heap]
struct Container {
	abc &Abc = unsafe { nil }
}

fn (mut c Container) m() fn () {
	mut cr := &c
	assert voidptr(c.abc) == voidptr(cr.abc)
	f := fn [mut cr] () {
		assert cr.abc.value == 1234
	}
	return f
}

fn test_auto_heap_var_and_non_ptr_as_closure_arg() {
	mut c := &Container{
		abc: &Abc{1234}
	}
	f := c.m()
	f()
	assert true
}

fn test_nested_closure_capture_context() {
	data := nested_closure_capture_data()
	assert nested_closure_capture_trace(data) == nested_closure_capture_trace_ref(data)
	assert nested_closure_capture_part1(data) == 21
	part2 := nested_closure_capture_part2(data) or { panic(err) }
	assert part2 == 8
}

fn nested_closure_capture_data() [][]int {
	return [
		[3, 0, 3, 7, 3],
		[2, 5, 5, 1, 2],
		[6, 5, 3, 3, 2],
		[3, 3, 5, 4, 9],
		[3, 5, 3, 9, 0],
	]
}

fn nested_closure_capture_trace(data [][]int) []int {
	return flat_map_indexed[[]int, int](data, fn [data] (y int, row []int) []int {
		return flat_map_indexed[int, int](row, fn [data, y] (x int, _ int) []int {
			return flat_map_indexed[[]int, int](nested_closure_grid_cross_walk(data.len, x, y), fn [data, x, y] (i int, grid_walk []int) []int {
				return grid_walk.map(fn [data, x, y, i] (pos int) int {
					return if i < 2 {
						data[y][pos]
					} else {
						data[pos][x]
					}
				})
			})
		})
	})
}

fn nested_closure_capture_trace_ref(data [][]int) []int {
	mut out := []int{}
	for y, row in data {
		for x, _ in row {
			for i, grid_walk in nested_closure_grid_cross_walk(data.len, x, y) {
				for pos in grid_walk {
					out << if i < 2 {
						data[y][pos]
					} else {
						data[pos][x]
					}
				}
			}
		}
	}
	return out
}

fn nested_closure_capture_part1(data [][]int) int {
	return flat_map_indexed[[]int, bool](data, fn [data] (y int, row []int) []bool {
		return map_indexed(row, fn [data, y] (x int, height int) bool {
			return map_indexed(nested_closure_grid_cross_walk(data.len, x, y), fn [data, x, y, height] (i int, grid_walk []int) bool {
				return grid_walk.map(fn [data, x, y, i] (pos int) int {
					return if i < 2 {
						data[y][pos]
					} else {
						data[pos][x]
					}
				}).all(it < height)
			}).any(it)
		}).filter(it)
	}).len
}

fn nested_closure_capture_part2(data [][]int) !int {
	return max(flat_map_indexed[[]int, int](data, fn [data] (y int, row []int) []int {
		return map_indexed(row, fn [data, y] (x int, height int) int {
			return fold(map_indexed(nested_closure_grid_cross_walk(data.len, x, y), fn [data, x, y, height] (i int, grid_walk []int) int {
				mut count := 0
				heights := grid_walk.map(fn [data, x, y, i] (pos int) int {
					return if i < 2 {
						data[y][pos]
					} else {
						data[pos][x]
					}
				})
				for h in heights {
					count++
					if h >= height {
						break
					}
				}
				return count
			}), 1, fn (acc int, elem int) int {
				return acc * elem
			})
		})
	}))!
}

fn nested_closure_range(size int, start int) [][]int {
	return [
		[]int{len: start, init: start - index - 1},
		[]int{len: size - start - 1, init: start + 1 + index},
	]
}

fn nested_closure_grid_cross_walk(size int, start_x int, start_y int) [][]int {
	return flat_map[int, []int]([start_x, start_y], fn [size] (elem int) [][]int {
		return nested_closure_range(size, elem)
	})
}