import * as _ from "@preserves/core";
import * as _i_Actor from "../runtime/actor";
import * as _i_sturdy from "./sturdy";

export const $bind = Symbol.for("bind");
export const $resolve = Symbol.for("resolve");

export type _ptr = _i_Actor.Ref;

export type _val = _.Value<_ptr>;

export type Resolve = {"sturdyref": _i_sturdy.SturdyRef, "observer": _ptr};

export type Bind = {"oid": _val, "key": _.Bytes, "target": _ptr};


export function Resolve({sturdyref, observer}: {sturdyref: _i_sturdy.SturdyRef, observer: _ptr}): Resolve {return {"sturdyref": sturdyref, "observer": observer};}

export function Bind({oid, key, target}: {oid: _val, key: _.Bytes, target: _ptr}): Bind {return {"oid": oid, "key": key, "target": target};}

export function asResolve(v: _val): Resolve {
    let result = toResolve(v);
    if (result === void 0) throw new TypeError(`Invalid Resolve: ${_.stringify(v)}`);
    return result;
}

export function toResolve(v: _val): undefined | Resolve {
    let result: undefined | Resolve;
    if (_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v)) {
        let _tmp0: (null) | undefined;
        _tmp0 = _.is(v.label, $resolve) ? null : void 0;
        if (_tmp0 !== void 0) {
            let _tmp1: (_i_sturdy.SturdyRef) | undefined;
            _tmp1 = _i_sturdy.toSturdyRef(v[0]);
            if (_tmp1 !== void 0) {
                let _tmp2: (_ptr) | undefined;
                _tmp2 = _.isPointer<_ptr>(v[1]) ? v[1].embeddedValue : void 0;
                if (_tmp2 !== void 0) {result = {"sturdyref": _tmp1, "observer": _tmp2};};
            };
        };
    };
    return result;
}

export function fromResolve(_v: Resolve): _val {
    return _.Record($resolve, [_i_sturdy.fromSturdyRef(_v["sturdyref"]), _.embed(_v["observer"])]);
}

export function asBind(v: _val): Bind {
    let result = toBind(v);
    if (result === void 0) throw new TypeError(`Invalid Bind: ${_.stringify(v)}`);
    return result;
}

export function toBind(v: _val): undefined | Bind {
    let result: undefined | Bind;
    if (_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v)) {
        let _tmp0: (null) | undefined;
        _tmp0 = _.is(v.label, $bind) ? null : void 0;
        if (_tmp0 !== void 0) {
            let _tmp1: (_val) | undefined;
            _tmp1 = v[0];
            if (_tmp1 !== void 0) {
                let _tmp2: (_.Bytes) | undefined;
                _tmp2 = _.Bytes.isBytes(v[1]) ? v[1] : void 0;
                if (_tmp2 !== void 0) {
                    let _tmp3: (_ptr) | undefined;
                    _tmp3 = _.isPointer<_ptr>(v[2]) ? v[2].embeddedValue : void 0;
                    if (_tmp3 !== void 0) {result = {"oid": _tmp1, "key": _tmp2, "target": _tmp3};};
                };
            };
        };
    };
    return result;
}

export function fromBind(_v: Bind): _val {return _.Record($bind, [_v["oid"], _v["key"], _.embed(_v["target"])]);}