struct Init {
	len int
}

fn test_array_init() {
	b := [1, 2, 3]
	mut a := []int{cap: b.len}
	a << 1
	assert '${a}, ${a.len}, ${a.cap}' == '[1], 1, 3'

	c := Init{
		len: 3
	}
	mut d := []string{cap: c.len}
	d << 'aaa'
	d << 'bbb'
	assert '${d}, ${d.len}, ${d.cap}' == "['aaa', 'bbb'], 2, 3"
}

fn test_nested_array_init() {
	mut a := [][]int{}
	mut b := [][][]string{cap: 10}
	mut c := [][][]string{len: 3, init: [][]string{len: 2}}
	// mut c := [][][]string{len: 2, init: [][]string{len: 2, init: []string{len: 2, init: 'hello'}}}
	a << [1, 2]
	a << [3, 4]
	b << [['foo', 'bar'], ['baz']]
	b << [['qux']]

	assert '${a}' == '[[1, 2], [3, 4]]'
	assert '${b}' == "[[['foo', 'bar'], ['baz']], [['qux']]]"
	assert '${c}' == '[[[], []], [[], []], [[], []]]'
}

fn test_array_init_with_default() {
	a1 := []int{len: 4, init: 2}
	assert '${a1}' == '[2, 2, 2, 2]'

	a2 := []int{len: 3, init: 12345}
	assert '${a2}' == '[12345, 12345, 12345]'

	b1 := []string{len: 3, init: 'abc'}
	assert '${b1}' == "['abc', 'abc', 'abc']"

	b2 := []string{len: 2, init: '111'}
	assert '${b2}' == "['111', '111']"
}

fn test_array_init_with_len_no_default() {
	a1 := []int{len: 4}
	assert '${a1}' == '[0, 0, 0, 0]'

	a2 := []string{len: 4}
	assert '${a2}' == "['', '', '', '']"

	a3 := []bool{len: 3}
	assert '${a3}' == '[false, false, false]'
}

fn test_array_int_full_options() {
	println('Test array of int values')

	a := []int{len: 2, cap: 10} // this creates an array with 2 items, initial capacity 10, default value of array type
	println('array a: length: ${a.len}, capacity: ${a.cap}, content: ${a}')
	assert a.len == 2
	assert a.cap == 10
	assert a.cap >= a.len
	assert a.str() == '[0, 0]'

	b := []int{len: 10, cap: 100, init: 1} // this creates an array with 10 one and initial capacity 100 elements, value given
	_ = b.clone() // discard result variable, sample
	println('array b: length: ${b.len}, capacity: ${b.cap}, content: ${b}')
	assert b.len == 10
	assert b.cap == 100
	assert b.cap >= b.len
	assert b.str() == '[1, 1, 1, 1, 1, 1, 1, 1, 1, 1]'

	mut c := []int{len: 2, cap: 10, init: 1} // this creates an array with 2 one and initial capacity 10 elements, value given
	_ = c.clone() // discard result variable, sample
	println('array c: length: ${c.len}, capacity: ${c.cap}, content: ${c}')
	assert c.len == 2
	assert c.cap == 10
	assert c.cap >= c.len
	assert c.str() == '[1, 1]'
	// add some items to the array, to check limits
	c << [3, 4, 5, 6, 7, 8, 9, 10] // add 8 items, from another array
	// update one item, to have the right number in the sequence ...
	c[1] = 2
	println('array c: length: ${c.len}, capacity: ${c.cap}, content now: ${c}')
	assert c.len == 10
	assert c.cap == 10
	assert c.cap >= c.len
	assert c.str() == '[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]'
	// add some more item after initial capacity, to ensure it's expandable
	c << [11, 12, 13, 14, 15, 16]
	println('array c: length: ${c.len}, capacity: ${c.cap}, content now: ${c}')
	assert c.len == 16
	assert c.cap >= c.len
	assert c.str() == '[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]'
}

fn test_array_string_full_options() {
	println('Test array of string values')

	a := []string{len: 2, cap: 10} // this creates an array with 2 items, initial capacity 10, default value of array type
	println('array a: length: ${a.len}, capacity: ${a.cap}') // ok
	println('array a: length: ${a.len}, capacity: ${a.cap}, content: "${a}"')
	assert a.len == 2
	assert a.cap == 10
	assert a.cap >= a.len
	assert a.str() == "['', '']"

	b := []string{len: 10, cap: 100, init: 'b'} // this creates an array with 10 'b', initial capacity 100 elements, value given
	_ = b.clone() // discard result variable, sample
	println('array b: length: ${b.len}, capacity: ${b.cap}') // ok
	println('array b: length: ${b.len}, capacity: ${b.cap}, content: ${b}')
	assert b.len == 10
	assert b.cap == 100
	assert b.cap >= b.len
	assert b.str() == "['b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b', 'b']"

	mut c := []string{len: 2, cap: 10, init: 'c'} // this creates an array with 2 'c' and initial capacity 10 elements, value given
	_ = c.clone() // discard result variable, sample
	println('array c: length: ${c.len}, capacity: ${c.cap}, content: ${c}')
	assert c.len == 2
	assert c.cap == 10
	assert c.cap >= c.len
	assert c.str() == "['c', 'c']"
	// add some items to the array, to check limits
	c << ['c', 'c', 'c', 'c', 'c', 'c', 'c', 'c'] // add 8 items, from another array
	// update some items, to have the right number in the sequence ...
	c[0] = 'a'
	c[1] = 'b'
	println('array c: length: ${c.len}, capacity: ${c.cap}, content now: ${c}')
	assert c.len == 10
	assert c.cap == 10
	assert c.cap >= c.len
	assert c.str() == "['a', 'b', 'c', 'c', 'c', 'c', 'c', 'c', 'c', 'c']"
	// add some more item after initial capacity, to ensure all is good
	c << ['11', '12', '13', '14', '15', '16']
	// c << ['11', nil, '13', '14', '15', '16'] // check later if/how to handle this ...
	println('array c: length: ${c.len}, capacity: ${c.cap}, content now: ${c}')
	assert c.len == 16
	assert c.cap >= c.len
	assert c.str() == "['a', 'b', 'c', 'c', 'c', 'c', 'c', 'c', 'c', 'c', '11', '12', '13', '14', '15', '16']"
}

struct MyStruct {
pub mut:
	ar []f32
}

fn test_array_init_in_struct_field() {
	m := MyStruct{
		ar: []f32{len: 4, init: 1.2}
	}
	println(m)
	assert m.ar.str() == '[1.2, 1.2, 1.2, 1.2]'
}

struct Aaa {
pub mut:
	a []int
}

struct IndexedDefaultArrayField {
	field []int = []int{len: 1, init: index}
}

fn test_array_init_cast_type_in_struct_field() {
	size := u32(5)
	st := &Aaa{
		a: []int{len: int(size)}
	}
	println(st)
	assert st.a.str() == '[0, 0, 0, 0, 0]'
}

fn test_array_of_struct_with_indexed_array_field_default() {
	st := []IndexedDefaultArrayField{len: 1}
	assert st.len == 1
	assert st[0].field == [0]
}

fn test_multi_dimensional_array_init() {
	a := [][]int{len: 2, init: []int{len: 4, init: 2}}
	assert '${a}' == '[[2, 2, 2, 2], [2, 2, 2, 2]]'

	b := [][]string{len: 3, init: []string{len: 2, init: 'abc'}}
	assert '${b}' == "[['abc', 'abc'], ['abc', 'abc'], ['abc', 'abc']]"

	c := [][]f64{len: 2, init: []f64{len: 2, init: 2.2}}
	assert '${c}' == '[[2.2, 2.2], [2.2, 2.2]]'

	d := [][]int{len: 3, init: []int{len: 2}}
	assert '${d}' == '[[0, 0], [0, 0], [0, 0]]'

	e := [][]string{len: 2, init: []string{len: 3}}
	assert '${e}' == "[['', '', ''], ['', '', '']]"

	f := [][]int{len: 3}
	assert '${f}' == '[[], [], []]'
}

fn test_array_init_direct_call() {
	assert []int{len: 2, init: 0}.len == 2
	assert []int{len: 3, init: 1}.map(it * 2) == [2, 2, 2]
}

// test array init with sumtype
type Alphabet = Abc | Xyz

struct Abc {
	val int
}

struct Xyz {
	val int
}

fn test_array_init_with_sumtype() {
	a := [Alphabet(Abc{1}), Xyz{2}]
	a0 := a[0]
	a1 := a[1]
	match a0 {
		Abc {
			assert a0.val == 1
		}
		else {
			assert false
		}
	}

	match a1 {
		Xyz {
			assert a1.val == 2
		}
		else {
			assert false
		}
	}
}

fn test_array_init_inferred_from_option() {
	a := read() or { [] }
	x := 1
	b := read() or {
		match x {
			1 {
				['1']
			}
			else {
				['2']
			}
		}
	}
	println(a)
	println(b)
}

fn read() ![]string {
	return error('failed')
}

fn test_multi_array_update_data() {
	mut a := [][][]int{len: 2, init: [][]int{len: 3, init: []int{len: 2}}}
	a[0][1][1] = 2
	println(a)
	assert '${a}' == '[[[0, 0], [0, 2], [0, 0]], [[0, 0], [0, 0], [0, 0]]]'
}

fn test_array_of_map_with_len_no_default() {
	mut arr := []map[int]int{len: 3}
	arr[0][0] = 0
	arr[1][1] = 1
	arr[2][2] = 2
	println(arr)
	assert arr == [{
		0: 0
	}, {
		1: 1
	}, {
		2: 2
	}]
}

fn empty_array_from_generic_typ[T]() []T {
	return []T.typ{}
}

fn test_array_init_from_typeof() {
	fixed := [1, 2, 3]!
	dyn := []typeof(fixed[0]){}
	assert typeof(dyn).name == '[]int'
	assert dyn.len == 0
}

fn test_array_init_from_generic_typ() {
	ints := empty_array_from_generic_typ[int]()
	assert typeof(ints).name == '[]int'
	assert ints.len == 0
}

fn test_nested_array_init_in_if_expr_with_index() {
	map_test := [][][]int{len: 10, init: if index == 0 || index == 9 {
		[][]int{len: 10, init: [1]}
	} else {
		[][]int{len: 10, init: if index == 0 || index == 9 { [1] } else { [] }}
	}}

	assert map_test.len == 10
	assert map_test[0].len == 10
	assert map_test[0][0] == [1]
	assert map_test[0][9] == [1]
	assert map_test[1].len == 10
	assert map_test[1][0] == [1]
	assert map_test[1][1] == []int{}
	assert map_test[1][9] == [1]
	assert map_test[9][5] == [1]
}