// TODO: remove this after the deprecation period for `?Type` representing both Result and Option passes.
fn opt_err_with_code(code int) !string {
    return error_with_code('hi', code)
}

fn test_err_with_code() {
    if w := opt_err_with_code(137) {
        assert false
        _ := w
    } else {
        assert err.str() == 'hi; code: 137'
        assert err.msg() == 'hi'
        assert err.code() == 137
    }
    v := opt_err_with_code(56) or {
        assert err.str() == 'hi; code: 56'
        assert err.msg() == 'hi'
        assert err.code() == 56
        return
    }
    assert false
    _ := v
}

fn opt_err() !string {
    return error('hi')
}

fn test_err() {
    v := opt_err() or {
        assert err.msg() == 'hi'
        return
    }
    assert false
    println(v) // suppress not used error
}

fn err_call(ok bool) !int {
    if !ok {
        return error('Not ok!')
    }
    return 42
}

fn ret_none() ?int {
    // return error('wtf') //none
    return none
}

fn test_option_for_base_type_without_variable() {
    mut val := err_call(true) or {
        assert false
        0
    }
    assert val == 42
    val = ret_none() or { return }
    assert false
    // This is invalid:
    // x := 5 or {
    // return
    // }
}

fn test_if_opt() {
    if val := err_call(false) {
        assert val == 42
    }
    assert 1 == 1
}

fn test_if_else_opt() {
    if val := err_call(true) {
        assert val == 42
    } else {
        assert false
    }
    if _ := err_call(false) {
        assert false
    } else {
        assert err.msg().len != 0
    }
}

fn for_opt_default() !string {
    return error('awww')
}

fn test_opt_default() {
    a := for_opt_default() or {
        // panic(err)
        'default'
    }
    assert a == 'default'
}

fn foo_ok() ?int {
    return 777
}

fn foo_str() ?string {
    return 'something'
}

fn propagate_option(b bool) !int {
    a := err_call(b)!
    return a
}

fn propagate_different_type(b bool) !bool {
    err_call(b)!
    return true
}

fn test_propagation() {
    println(1)
    a := propagate_option(true) or { 0 }
    println(2)
    assert a == 42
    println(3)
    if _ := propagate_option(false) {
        assert false
    }
    println(4)
    b := propagate_different_type(true) or { false }
    assert b == true
    println(5)
    if _ := propagate_different_type(false) {
        assert false
    }
    println(6)
}

fn test_q() {
    assert foo_ok()? == 777
}

fn or_return_val() int {
    a := ret_none() or { return 1 }
    return a
}

fn or_return_error() !int {
    a := ret_none() or { return error('Nope') }
    return a
}

fn or_return_none() ?int {
    a := ret_none() or { return none }
    return a
}

fn test_or_return() {
    assert or_return_val() == 1
    if _ := or_return_error() {
        assert false
    } else {
        assert err.msg().len != 0
    }
    if _ := or_return_none() {
        assert false
    } else {
        assert err.msg().len == 0
    }
}

fn test_reassignment() {
    mut x2 := foo_ok() or {
        assert false
        return
    }
    assert x2 == 777
    x2 = 100
    assert x2 == 100
    x2++
    assert x2 == 101

    mut x3 := 0
    x3 = foo_ok() or {
        assert false
        return
    }
    assert x3 == 777
}

struct OptionFieldsStruct {
mut:
    text ?string
    n    ?int
    n1   ?int = 1
}

fn get_opt_struct() ?OptionFieldsStruct {
    return OptionFieldsStruct{}
}

fn test_option_field() ? {
    mut v := OptionFieldsStruct{}
    assert v.text or { 'default' } == 'default'
    assert v.n or { 42 } == 42
    assert v.n1 or { 42 } == 1
    assert (v.n or { v.n1? }) == 1

    if n := v.n {
        assert false
    } else {
        assert true
    }
    if n1 := v.n1 {
        assert n1 == 1
    } else {
        assert false
    }

    n := v.n or { 10 }
    assert n == 10
    n1 := v.n1 or { 10 }
    assert n1 == 1
    n1_1 := v.n1? + (v.n or { 10 })
    assert n1_1 == 11

    v.text = 'text'
    assert v.text? == 'text'
    v.n = 42
    assert v.n? == 42
    v.n1 = 43
    assert v.n1? == 43

    v = OptionFieldsStruct{
        text: 'init'
        n:    0
        n1:   none
    }
    assert v.text? == 'init'
    assert v.n? == 0
    assert v.n1 or { 42 } == 42

    assert get_opt_struct()?.n1? == 1
}

fn opt_ptr(a &int) ?&int {
    if isnil(a) {
        return none
    }
    return unsafe { a }
}

fn test_opt_ptr() {
    a := 3
    mut r := opt_ptr(&a) or { unsafe { &int(0) } }
    assert r == &a
    r = opt_ptr(unsafe { &int(0) }) or { return }
    assert false
}

/*
// QTODO
fn multi_return_opt(err bool) (string, string) {
    if err {
        return error('oops')
    }
    return 'hello', 'v'
}

fn test_multi_return_opt() {
    a, b := multi_return_opt(false) or {
        panic(err)
    }
    assert a == 'hello' && b == 'v'
    _, _ := multi_return_opt(true) or {
        assert err == 'oops'
        return
    }
}
*/

fn test_option_val_with_empty_or() {
    ret_none() or {}
    assert true
}

fn test_option_void_return_types_of_anon_fn() {
    f := fn (i int) ! {
        if i == 0 {
            return error('0')
        }

        return
    }

    f(0) or {
        assert err.msg() == '0'
        return
    }
}

struct Foo {
    f fn (int) ! = unsafe { nil }
}

fn test_option_void_return_types_of_anon_fn_in_struct() {
    foo := Foo{
        f: fn (i int) ! {
            if i == 0 {
                return error('0')
            }

            return
        }
    }

    foo.f(0) or {
        assert err.msg() == '0'
        return
    }
}

type AA = BB | CC

struct BB {
    str string
}

struct CC {
    str string
}

fn option_sum_type(a int) !AA {
    match a {
        1 {
            return BB{'Test'}
        }
        2 {
            return CC{'Test'}
        }
        else {
            return error('Wrong number')
        }
    }
}

fn test_option_sum_type() {
    res1 := option_sum_type(1) or {
        assert false
        BB{}
    }
    res2 := option_sum_type(2) or {
        assert false
        CC{}
    }
    if res1 is BB {
        assert res1.str == 'Test'
    } else {
        assert false
    }
    if res2 is CC {
        assert res2.str == 'Test'
    } else {
        assert false
    }
    option_sum_type(3) or {
        assert true
        return
    }
    assert false
}

fn foo() ?int {
    return 0
}

fn foo2() ?int {
    for _ in 0 .. 5 {
        return foo() or { continue }
    }
    return 0
}

fn test_return_or() {
    x := foo2() or { return }
    assert x == 0
}

// For issue #16058: cgen error: exists spaces in the name of the ?&C.struct
fn get_opt_pointer_to_c_struct() ?&C.stat {
    return none
}

fn test_option_ref_c_struct_gen() {
    _ := get_opt_pointer_to_c_struct() or { &C.stat{} }
}

// For issue #16070: cgen error: missing * of option non-ref structs
fn get_opt_to_c_struct() ?C.stat {
    return none
}

fn test_option_c_struct_gen() {
    _ := get_opt_to_c_struct() or { C.stat{} }
}

// For issue #16062: checker disallowed the return of voidptr(nil) in or block
struct Bar {}

fn get_bar(should_return_value bool) ?&Bar {
    if should_return_value {
        return unsafe { nil }
    }
    return none
}

fn test_allow_returning_an_optional_pointer_to_a_struct() {
    a := get_bar(true)?
    assert a == unsafe { nil }

    x := get_bar(false) or {
        assert true
        unsafe { nil }
    }
    assert x == unsafe { nil }

    get_bar(false) or { unsafe { nil } }
    assert true
}

struct AFoo {
mut:
    name string
}

fn (mut f AFoo) opt_string(arr ?[]int) ?string {
    return arr?.len.str()
}

fn test_creating_an_option_from_a_struct_value() {
    mut m := ?AFoo(AFoo{})
    assert m?.opt_string([1, 2, 3])? == '3'
    m?.name = 'foo'
    assert m?.name == 'foo'
}