import * as _ from "@preserves/core";
import * as _i_Protocol from "../transport/protocol";

export const $assert = Symbol.for("assert");
export const $message = Symbol.for("message");
export const $retract = Symbol.for("retract");
export const $sync = Symbol.for("sync");

export type _ptr = _i_Protocol.WireRef;

export type _val = _.Value<_ptr>;

export type Assertion = _val;

export type Handle = number;

export type Event = (
    {"_variant": "Assert", "value": Assert} |
    {"_variant": "Retract", "value": Retract} |
    {"_variant": "Message", "value": Message} |
    {"_variant": "Sync", "value": Sync}
);

export type Oid = number;

export type Turn = Array<TurnEvent>;

export type TurnEvent = {"oid": Oid, "event": Event};

export type Assert = {"assertion": Assertion, "handle": Handle};

export type Retract = {"handle": Handle};

export type Message = {"body": Assertion};

export type Sync = {"peer": _ptr};


export const _toPtr = (v: _val) => {
    let result: undefined | _ptr;
    result = _i_Protocol.toWireRef(v);
    return result;
};

export function Assertion(value: _val): Assertion {return value;}

export function Handle(value: number): Handle {return value;}

export namespace Event {
    export function Assert(value: Assert): Event {return {"_variant": "Assert", "value": value};};
    export function Retract(value: Retract): Event {return {"_variant": "Retract", "value": value};};
    export function Message(value: Message): Event {return {"_variant": "Message", "value": value};};
    export function Sync(value: Sync): Event {return {"_variant": "Sync", "value": value};};
}

export function Oid(value: number): Oid {return value;}

export function Turn(value: Array<TurnEvent>): Turn {return value;}

export function TurnEvent({oid, event}: {oid: Oid, event: Event}): TurnEvent {return {"oid": oid, "event": event};}

export function Assert({assertion, handle}: {assertion: Assertion, handle: Handle}): Assert {return {"assertion": assertion, "handle": handle};}

export function Retract(handle: Handle): Retract {return {"handle": handle};}

export function Message(body: Assertion): Message {return {"body": body};}

export function Sync(peer: _ptr): Sync {return {"peer": peer};}

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

export function toAssertion(v: _val): undefined | Assertion {
    let _tmp0: (_val) | undefined;
    let result: undefined | Assertion;
    _tmp0 = v;
    if (_tmp0 !== void 0) {result = _tmp0;};
    return result;
}

export function fromAssertion(_v: Assertion): _val {return _v;}

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

export function toHandle(v: _val): undefined | Handle {
    let _tmp0: (number) | undefined;
    let result: undefined | Handle;
    _tmp0 = typeof v === 'number' ? v : void 0;
    if (_tmp0 !== void 0) {result = _tmp0;};
    return result;
}

export function fromHandle(_v: Handle): _val {return _v;}

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

export function toEvent(v: _val): undefined | Event {
    let _tmp0: (Assert) | undefined;
    let result: undefined | Event;
    _tmp0 = toAssert(v);
    if (_tmp0 !== void 0) {result = {"_variant": "Assert", "value": _tmp0};};
    if (result === void 0) {
        let _tmp1: (Retract) | undefined;
        _tmp1 = toRetract(v);
        if (_tmp1 !== void 0) {result = {"_variant": "Retract", "value": _tmp1};};
        if (result === void 0) {
            let _tmp2: (Message) | undefined;
            _tmp2 = toMessage(v);
            if (_tmp2 !== void 0) {result = {"_variant": "Message", "value": _tmp2};};
            if (result === void 0) {
                let _tmp3: (Sync) | undefined;
                _tmp3 = toSync(v);
                if (_tmp3 !== void 0) {result = {"_variant": "Sync", "value": _tmp3};};
            };
        };
    };
    return result;
}

export function fromEvent(_v: Event): _val {
    switch (_v._variant) {
        case "Assert": {return fromAssert(_v.value);};
        case "Retract": {return fromRetract(_v.value);};
        case "Message": {return fromMessage(_v.value);};
        case "Sync": {return fromSync(_v.value);};
    };
}

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

export function toOid(v: _val): undefined | Oid {
    let _tmp0: (number) | undefined;
    let result: undefined | Oid;
    _tmp0 = typeof v === 'number' ? v : void 0;
    if (_tmp0 !== void 0) {result = _tmp0;};
    return result;
}

export function fromOid(_v: Oid): _val {return _v;}

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

export function toTurn(v: _val): undefined | Turn {
    let result: undefined | Turn;
    if (_.Array.isArray(v)) {
        let _tmp0: (Array<TurnEvent>) | undefined;
        _tmp0 = [];
        for (const _tmp1 of v) {
            let _tmp2: (TurnEvent) | undefined;
            _tmp2 = toTurnEvent(_tmp1);
            if (_tmp2 !== void 0) {_tmp0.push(_tmp2); continue;};
            _tmp0 = void 0;
            break;
        };
        if (_tmp0 !== void 0) {result = _tmp0;};
    };
    return result;
}

export function fromTurn(_v: Turn): _val {return _v.map(v => fromTurnEvent(v));}

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

export function toTurnEvent(v: _val): undefined | TurnEvent {
    let result: undefined | TurnEvent;
    if (_.Array.isArray(v) && v.length === 2) {
        let _tmp0: (Oid) | undefined;
        _tmp0 = toOid(v[0]);
        if (_tmp0 !== void 0) {
            let _tmp1: (Event) | undefined;
            _tmp1 = toEvent(v[1]);
            if (_tmp1 !== void 0) {result = {"oid": _tmp0, "event": _tmp1};};
        };
    };
    return result;
}

export function fromTurnEvent(_v: TurnEvent): _val {return [fromOid(_v["oid"]), fromEvent(_v["event"])];}

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

export function toAssert(v: _val): undefined | Assert {
    let result: undefined | Assert;
    if (_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v)) {
        let _tmp0: (null) | undefined;
        _tmp0 = _.is(v.label, $assert) ? null : void 0;
        if (_tmp0 !== void 0) {
            let _tmp1: (Assertion) | undefined;
            _tmp1 = toAssertion(v[0]);
            if (_tmp1 !== void 0) {
                let _tmp2: (Handle) | undefined;
                _tmp2 = toHandle(v[1]);
                if (_tmp2 !== void 0) {result = {"assertion": _tmp1, "handle": _tmp2};};
            };
        };
    };
    return result;
}

export function fromAssert(_v: Assert): _val {
    return _.Record($assert, [fromAssertion(_v["assertion"]), fromHandle(_v["handle"])]);
}

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

export function toRetract(v: _val): undefined | Retract {
    let result: undefined | Retract;
    if (_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v)) {
        let _tmp0: (null) | undefined;
        _tmp0 = _.is(v.label, $retract) ? null : void 0;
        if (_tmp0 !== void 0) {
            let _tmp1: (Handle) | undefined;
            _tmp1 = toHandle(v[0]);
            if (_tmp1 !== void 0) {result = {"handle": _tmp1};};
        };
    };
    return result;
}

export function fromRetract(_v: Retract): _val {return _.Record($retract, [fromHandle(_v["handle"])]);}

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

export function toMessage(v: _val): undefined | Message {
    let result: undefined | Message;
    if (_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v)) {
        let _tmp0: (null) | undefined;
        _tmp0 = _.is(v.label, $message) ? null : void 0;
        if (_tmp0 !== void 0) {
            let _tmp1: (Assertion) | undefined;
            _tmp1 = toAssertion(v[0]);
            if (_tmp1 !== void 0) {result = {"body": _tmp1};};
        };
    };
    return result;
}

export function fromMessage(_v: Message): _val {return _.Record($message, [fromAssertion(_v["body"])]);}

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

export function toSync(v: _val): undefined | Sync {
    let result: undefined | Sync;
    if (_.Record.isRecord<_val, _.Tuple<_val>, _ptr>(v)) {
        let _tmp0: (null) | undefined;
        _tmp0 = _.is(v.label, $sync) ? null : void 0;
        if (_tmp0 !== void 0) {
            let _tmp1: (_ptr) | undefined;
            _tmp1 = _toPtr(v[0]);
            if (_tmp1 !== void 0) {result = {"peer": _tmp1};};
        };
    };
    return result;
}

export function fromSync(_v: Sync): _val {return _.Record($sync, [_v["peer"]]);}