// vtest retry: 3

fn f(n int) ?f64 {
	if n < 0 {
		return none
	}
	return n + f64(n) / 2
}

fn g(n int) ? {
	if n % 2 == 0 {
		return none
	} else {
		return
	}
}

fn test_opt_val_wait() {
	h1 := spawn f(-1)
	h2 := spawn f(3)
	r1 := h1.wait() or { 17.0 }
	r2 := h2.wait() or { 23.0 }
	assert r1 == 17.0
	assert r2 == 4.5
}

fn test_opt_void_wait() {
	h1 := spawn g(2)
	h2 := spawn g(3)
	mut x := 0
	mut y := 0
	h1.wait() or { x = 1 }
	h2.wait() or { y = 1 }
	assert x == 1
	assert y == 0
}

fn propagate(n int, m int) ?f64 {
	h1 := spawn f(n)
	h2 := spawn g(m)
	r := h1.wait()?
	h2.wait()?
	return r
}

fn test_propagate() {
	x := propagate(5, 3) or { 27.0 }
	y := propagate(-3, 3) or { 29.0 }
	z := propagate(5, 2) or { 31.0 }
	assert x == 7.5
	assert y == 29.0
	assert z == 31.0
}

fn test_array_void_iter() {
	mut r := []thread ?{}
	for i in 0 .. 3 {
		r << spawn g(i)
	}
	mut res := []int{len: 3, init: 17}
	for i, t in r {
		t.wait() or { res[i] = i }
	}
	assert res[0] == 0
	assert res[1] == 17
	assert res[2] == 2
}

fn test_array_val_iter() {
	mut r := []thread ?f64{}
	for i in -1 .. 2 {
		r << spawn f(i)
	}
	mut res := []f64{len: 3}
	for i, t in r {
		res[i] = t.wait() or { 17.0 }
	}
	assert res[0] == 17.0
	assert res[1] == 0.0
	assert res[2] == 1.5
}

fn wait_array_option_values() ?[]f64 {
	mut threads := []thread ?f64{}
	for i in 0 .. 3 {
		threads << spawn f(i)
	}
	values := threads.wait()?
	return values
}

fn wait_array_result_void() ! {
	mut threads := []thread !{}
	threads << spawn ok_result_void(true)
	threads << spawn ok_result_void(false)
	threads.wait()!
}

fn ok_result_void(ok bool) ! {
	if !ok {
		return error('boom')
	}
}

fn test_array_wait_option_propagates() {
	assert wait_array_option_values() or { []f64{} } == [0.0, 1.5, 3.0]
}

fn test_array_wait_result_void_propagates() {
	wait_array_result_void() or {
		assert err.msg() == 'boom'
		return
	}
	assert false
}

// For issue 16065
fn get_only_a_option_return(return_none bool) ? {
	if return_none {
		return
	}
	return none
}

fn get_only_a_result_return() ! {
	return error('msg')
}

fn test_only_a_option_return() {
	t1 := spawn get_only_a_option_return(true)
	t1.wait() or { assert false }
	t2 := spawn get_only_a_option_return(false)
	t2.wait() or { assert true }
	assert true
}

fn test_only_a_result_return() {
	t := spawn get_only_a_result_return()
	t.wait() or { assert true }
	assert true
}