import os

const vexe = @VEXE
const tests_dir = os.dir(@FILE)
const v3_dir = os.dir(tests_dir)
const vlib_dir = os.dir(v3_dir)
const v3_src = os.join_path(v3_dir, 'v3.v')

fn test_optional_struct_selector_assignment_mutates_payload_storage() {
    v3_bin := os.join_path(os.temp_dir(), 'v3_optional_struct_lvalue_test')
    build :=
        os.execute('${vexe} -gc none -path "${vlib_dir}|@vlib|@vmodules" -o ${v3_bin} ${v3_src}')
    assert build.exit_code == 0, build.output

    src := os.join_path(os.temp_dir(), 'v3_optional_struct_lvalue_input.v')
    os.write_file(src, "struct AFoo {
mut:
    name string
}

struct Inner {
mut:
    name string
}

struct Holder {
mut:
    opt ?Inner
}

struct ResultHolder {
mut:
    res !Inner
}

struct Outer {
mut:
    inner Inner
}

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

fn guarded_failure() ?AFoo {
    mut m := ?AFoo(none)
    m?.name = 'bad'
    return m
}

fn fail_inner() !Inner {
    return error('boom')
}

fn mutate_result_source(mut h ResultHolder) ! {
    h.res!.name = 'result'
}

fn mutate_explicit_or_source(mut holder Holder) {
    (holder.opt or {
        assert false
        return
    }).name = 'ok'
}

fn mutate_explicit_or_none() {
    mut holder := Holder{
        opt: none
    }
    (holder.opt or {
        assert err.msg() == ''
        println('none')
        return
    }).name = 'bad'
    assert false
}

fn mutate_result_explicit_or_ok(mut h ResultHolder) {
    (h.res or {
        assert false
        return
    }).name = 'explicit-result'
}

fn mutate_result_explicit_or_err(mut h ResultHolder) {
    (h.res or {
        assert err.msg() == 'boom'
        println('boom')
        return
    }).name = 'bad'
    assert false
}

fn main() {
    mut m := ?AFoo(AFoo{})
    assert m?.opt_string([1, 2, 3])? == '3'
    m?.name = 'foo'
    assert m?.name == 'foo'
    mut holder := Holder{
        opt: Inner{}
    }
    holder.opt?.name = 'holder'
    assert holder.opt?.name == 'holder'
    mut outer := ?Outer(Outer{})
    outer?.inner.name = 'deep'
    assert outer?.inner.name == 'deep'
    mut result_ok := ResultHolder{
        res: Inner{}
    }
    mutate_result_source(mut result_ok)!
    assert result_ok.res!.name == 'result'
    mutate_result_explicit_or_ok(mut result_ok)
    assert result_ok.res!.name == 'explicit-result'
    mut result_bad := ResultHolder{
        res: fail_inner()
    }
    mut saw_result_err := false
    mutate_result_source(mut result_bad) or {
        assert err.msg() == 'boom'
        saw_result_err = true
    }
    assert saw_result_err
    mutate_result_explicit_or_err(mut result_bad)
    mutate_explicit_or_source(mut holder)
    assert holder.opt?.name == 'ok'
    mutate_explicit_or_none()
    guarded_failure() or {
        assert err.msg() == ''
        println('ok')
        return
    }
    assert false
}
") or {
        panic(err)
    }

    bin := os.join_path(os.temp_dir(), 'v3_optional_struct_lvalue_input')
    compile := os.execute('${v3_bin} ${src} -b c -o ${bin}')
    assert compile.exit_code == 0, compile.output
    assert !compile.output.contains('C compilation failed'), compile.output

    c_code := os.read_file(bin + '.c') or { panic(err) }
    assert c_code.contains('m.value.name ='), c_code
    assert c_code.contains('holder.opt.value.name ='), c_code
    assert c_code.contains('outer.value.inner.name ='), c_code
    assert c_code.contains('holder->opt.value.name =') || c_code.contains('holder.opt.value.name ='), c_code

    assert c_code.contains('if (!m.ok)'), c_code
    assert c_code.contains('if (!holder.opt.ok)'), c_code
    assert c_code.contains('if (!outer.ok)'), c_code
    assert c_code.contains('.err = h->res.err') || c_code.contains('.err = h.res.err'), c_code
    assert c_code.contains('IError err = holder.opt.err')
        || c_code.contains('IError err = holder->opt.err'), c_code
    assert c_code.contains('IError err = h->res.err') || c_code.contains('IError err = h.res.err'), c_code

    mutate_result_start := c_code.index('\nOptional mutate_result_source(ResultHolder* h) {') or {
        -1
    }
    assert mutate_result_start >= 0, c_code
    mutate_result_tail := c_code[mutate_result_start..]
    mutate_result_guard := mutate_result_tail[..mutate_result_tail.index('h->res.value.name') or {
        mutate_result_tail.len
    }]
    assert !mutate_result_guard.contains('return (Optional){.ok = false};'), mutate_result_guard
    for line in c_code.split_into_lines() {
        assert !(line.contains('__or_val_') && line.contains('.name =')), line
        assert !(line.contains('__or_val_') && line.contains('.inner.name =')), line
    }

    run := os.execute(bin)
    assert run.exit_code == 0, run.output
    assert run.output.trim_space() == 'boom\nnone\nok'
}