struct Aaa {
pub mut:
	v []int
}

struct Bbb {
pub mut:
	a []Aaa
}

fn foo(b int, mut a []int) {
	a[0] = 7
	// a << 4
}

fn test_mut() {
	mut numbers := [1, 2, 3]
	foo(7, mut numbers)
	assert numbers.len == 3
	// TODO: bring back once << works with mutable args
	// assert numbers.len == 4
	// assert numbers[0] == 7
	// assert numbers[3] == 4
	println(numbers)
	n := 1
	mut b := (&n)

	unsafe {
		(*b) = 10
	}
	// mut b := mut a
	// b = 10
}

fn test_mut_2() {
	zero := 0
	mut b := Bbb{}
	b.a << Aaa{}
	b.a[0].v = [9, 8, 7]
	b.a[0].v << 6
	b.a[zero].v << 5
	b.a[0].v[zero] = 3
	b.a[0].v[b.a[zero].v[zero]] += 2 - 1 // TODO
	b.a[0].v[b.a[0].v[zero]] += 2 - 1 // TODO
	assert b.a[0].v.len == 5
	assert b.a[0].v[0] == 3
	assert b.a[0].v[1] == 8
	assert b.a[0].v[2] == 7
	assert b.a[0].v[3] == 8
	assert b.a[0].v[4] == 5
}

fn test_mut_3() {
	mut indices := []int{len: 3}
	mut results := []string{}

	for i, mut v in indices {
		v = i
		a := v
		println('${i} ${v} ${a}')
		results << '${i} ${v} ${a}'
	}
	assert results[0] == '0 0 0'
	assert results[1] == '1 1 1'
	assert results[2] == '2 2 2'
}

struct St {
mut:
	n int
}

fn f(mut x St) {
	mut y := St{
		n: 2
	}
	a := x
	b := y
	x.n = 3
	y.n = 4
	println('${a.n} ${b.n}')
	assert '${a.n} ${b.n}' == '1 2'
}

fn test_mut_4() {
	mut x := St{
		n: 1
	}
	f(mut x)
}

fn test_mut_5() {
	mut arr1 := []int{len: 2}
	mut arr2 := []int{len: 2}
	mut results := []string{}

	for i, mut v in arr1 {
		for ii, mut vv in arr2 {
			v = i
			a := v
			println('${i} ${v} ${a}')
			results << '${i} ${v} ${a}'

			vv = ii
			aa := vv
			println('${ii} ${vv} ${aa}')
			results << '${ii} ${vv} ${aa}'
		}
	}

	assert results[0] == '0 0 0'
	assert results[1] == '0 0 0'
	assert results[2] == '0 0 0'
	assert results[3] == '1 1 1'
	assert results[4] == '1 1 1'
	assert results[5] == '0 0 0'
	assert results[6] == '1 1 1'
	assert results[7] == '1 1 1'
}

fn test_mut_6() {
	mut results := []int{}
	mut arr := []int{len: 3}
	for _, mut v in arr {
		v = v + 1
		println(v)
		results << v
	}
	assert results[0] == 1
	assert results[1] == 1
	assert results[2] == 1
}

fn test_mut_7() {
	mut arr := []int{len: 3}
	mut results := []int{}
	for _, mut v in arr {
		v = v + 1 // v: 1
		mut vv := v // vv: 1, v: 1
		vv = vv + v // vv: 2, v: 1
		println(v)
		println(vv)
		results << v
		results << vv
	}
	assert results[0] == 1
	assert results[1] == 2
	assert results[2] == 1
	assert results[3] == 2
	assert results[4] == 1
	assert results[5] == 2
}

fn test_mut_8() {
	mut indices := []int{len: 1}
	for i, mut v in indices {
		v = i
		mut b := v
		println(typeof(i).name)
		println(typeof(v).name)
		println(typeof(b).name)
		u := [v, 5, 6]
		println(typeof(u).name)
		println(u)
		assert typeof(b).name == 'int'
		assert typeof(u).name == '[]int'
		assert u == [0, 5, 6]
	}
}

fn test_mut_9() {
	mut arr := [0, 0, 0]
	mut results := []string{}
	for _, mut v in arr {
		v = v + 1 // v: 1
		mut vv := v // vv: 1, v: 1
		vv = vv + v // vv: 2, v: 1
		foo := {
			'a': v
			'b': vv
		}
		println(v)
		println(vv)
		println(foo)
		results << '${v}'
		results << '${vv}'
		results << '${foo}'
	}
	assert results[0] == '1'
	assert results[1] == '2'
	assert results[2] == "{'a': 1, 'b': 2}"
	assert results[3] == '1'
	assert results[4] == '2'
	assert results[5] == "{'a': 1, 'b': 2}"
	assert results[6] == '1'
	assert results[7] == '2'
	assert results[8] == "{'a': 1, 'b': 2}"
}

fn foo1(mut arr [][]int) {
	mut results := []int{}
	for _, mut j in arr {
		for _, mut k in j {
			k = k + 1 // k: 1
			mut kk := k // kk: 1, k: 1
			kk = kk + k // kk: 2, k: 1
			k++ // kk: 2, k: 2
			kk++ // kk: 3, k: 2
			println(k)
			println(kk)
			results << k
			results << kk
		}
	}
	assert results[0] == 2
	assert results[1] == 3
	assert results[2] == 2
	assert results[3] == 3
}

fn test_mut_10() {
	mut arr := [[0, 0]]
	foo1(mut arr)
}

fn foo2(mut arr [][]int) {
	mut results := []int{}
	for _, mut j in arr {
		for _, mut k in j {
			k = k + 1 // k: 1
			mut kk := k // kk: 1, k: 1
			kk = kk + k // kk: 2, k: 1
			k-- // kk: 2, k: 2
			kk-- // kk: 3, k: 2
			println(k)
			println(kk)
			results << k
			results << kk
		}
	}
	assert results[0] == 0
	assert results[1] == 1
	assert results[2] == 0
	assert results[3] == 1
}

fn test_mut_11() {
	mut arr := [[0, 0]]
	foo2(mut arr)
}

fn foo3(mut arr [][]int) {
	mut results := []string{}
	for _, mut j in arr {
		j[0] += 2
		println(j) // [2, 0]
		results << '${j}'
	}
	assert results[0] == '[2, 0]'
}

fn test_mut_12() {
	mut arr := [[0, 0]]
	foo3(mut arr)
}

struct Foo {
mut:
	foo int
}

fn foo4(mut f Foo) {
	f2 := unsafe { &f }
	f.foo = 100
	println(f.foo)
	println(f2.foo)
	assert f.foo == 100
	assert f2.foo == 100
}

fn test_mut_13() {
	mut f := Foo{
		foo: 1
	}
	foo4(mut f)
}

fn foo5(mut arr []int) {
	arr2 := unsafe { &arr }
	arr[0] = 0
	println(arr[0]) // 0
	assert arr[0] == 0
	unsafe {
		println(arr2[0]) // 0
		assert arr2[0] == 0
	}
}

fn test_mut_14() {
	mut arr := [1, 2, 3]
	foo5(mut arr)
}

fn foo6(mut arr [3]int) {
	arr2 := unsafe { &arr }
	arr[0] = 0
	println(arr[0]) // 0
	assert arr[0] == 0
	unsafe {
		println(arr2[0]) // 0
		assert arr2[0] == 0
	}
}

fn test_mut_15() {
	mut arr := [1, 2, 3]!
	foo6(mut arr)
}

fn foo7(mut m map[string]int) {
	m2 := unsafe { &m }
	m['one'] = 1
	println(m['one']) // 1
	assert m['one'] == 1
	unsafe {
		println(m2['one']) // 1
		assert m2['one'] == 1
	}
}

fn test_mut_16() {
	mut m := {
		'one': 100
		'two': 2
	}
	foo7(mut m)
}

fn test_mut_17() {
	mut arr := [{
		'foo': 1
	}]
	for _, mut j in arr {
		mut k := j.clone()
		j['foo'] = 0
		unsafe {
			k['foo'] = 10
		}
		println(j)
		println(k)
		assert j == {
			'foo': 0
		}
		assert k == {
			'foo': 10
		}
	}
}

fn foo8(mut a [1]int) {
	a2 := a
	a[0] = 100
	println(a)
	println(a2)
	assert '${a}' == '[100]'
	assert '${a2}' == '[1]'
}

fn test_mut_18() {
	mut a := [1]!
	foo8(mut a)
}