fn foo(a int) !int {
	if a < 0 {
		return error('foo')
	}
	return a
}

fn bar(a int) !int {
	return foo(a) or {
		if a < 0 {
			-1
		} else {
			return error('bar')
		}
	}
}

fn baz(a int) !int {
	return foo(a) or {
		if a < 0 {
			-1
		} else {
			-2
		}
	}
}

fn qux(a int) ?int {
	if a < 0 {
		return none
	}
	return a
}

fn quux(a int) ?int {
	return qux(a) or {
		if a < 0 {
			-1
		} else {
			return none
		}
	}
}

fn test_if_expr_in_result_or_block_with_return() {
	assert bar(0)! == 0
	assert bar(-1)! == -1
	assert bar(1)! == 1
}

fn test_if_expr_in_result_or_block_simple() {
	assert baz(0)! == 0
	assert baz(-1)! == -1
	assert baz(1)! == 1
}

fn test_if_expr_in_option_or_block_with_return() {
	assert quux(0)? == 0
	assert quux(-1)? == -1
	assert quux(1)? == 1
}

fn test_nested_if_in_or_block() {
	get_val := fn (x int) !int {
		if x < 0 {
			return error('negative')
		}
		return x * 2
	}
	result := get_val(-5) or {
		if true {
			if false {
				100
			} else {
				-10
			}
		} else {
			200
		}
	}
	assert result == -10
}

fn test_if_expr_with_multiple_branches_in_or_block() {
	compute := fn (x int) !int {
		if x == 0 {
			return error('zero')
		}
		return x
	}
	val := compute(0) or {
		match err.msg() {
			'zero' {
				1
			}
			'negative' {
				2
			}
			else {
				3
			}
		}
	}
	assert val == 1
}

struct IfExprEmptyReply {
	value int
}

struct IfExprRedisError {
	msg_ string
}

fn (e IfExprRedisError) msg() string {
	return e.msg_
}

fn (e IfExprRedisError) code() int {
	return 0
}

const if_expr_nil_reply = IfExprRedisError{'nil'}

type IfExprReply = IfExprEmptyReply | IfExprRedisError

fn if_expr_read_reply(msg string) !IfExprReply {
	return IError(IfExprRedisError{msg})
}

fn if_expr_decode_reply(msg string) IfExprReply {
	return if_expr_read_reply(msg) or {
		if err is IfExprRedisError {
			if err == if_expr_nil_reply {
				IfExprEmptyReply{0}
			} else {
				err
			}
		} else {
			panic(err)
		}
	}
}

fn test_if_expr_in_or_block_with_smartcasted_interface_sumtype_value() {
	reply1 := if_expr_decode_reply('nil')
	assert reply1 is IfExprEmptyReply
	if reply1 is IfExprEmptyReply {
		assert reply1.value == 0
	}

	reply2 := if_expr_decode_reply('x')
	assert reply2 is IfExprRedisError
	if reply2 is IfExprRedisError {
		assert reply2.msg_ == 'x'
	}
}