Promises.alusus

import "Srl/errors";
import "closure";

module Promises {
    use Srl;
    def unresolvedPromises: SrdRef[Promise[Int]];
    def unresolvedPromisesLocker: ptr[func](func {});
    def unresolvedPromisesUnlocker: ptr[func](func {});

    func addUnresolvedPromise[ResultType: type](p: SrdRef[Promise[ResultType]]) {
        unresolvedPromisesLocker();
        p.prevUnresolvedPromise.release();
        p.nextUnresolvedPromise = unresolvedPromises;
        if not unresolvedPromises.isNull() {
            unresolvedPromises.prevUnresolvedPromise = castSrdRef[p, Promise[Int]];
        }
        unresolvedPromises = castSrdRef[p, Promise[Int]];
        unresolvedPromisesUnlocker();
    }

    func removeUnresolvedPromise[ResultType: type](p: SrdRef[Promise[ResultType]]) {
        unresolvedPromisesLocker();
        if not p.nextUnresolvedPromise.isNull() p.nextUnresolvedPromise.prevUnresolvedPromise = p.prevUnresolvedPromise;
        if not p.prevUnresolvedPromise.isNull() p.prevUnresolvedPromise.nextUnresolvedPromise = p.nextUnresolvedPromise
        else unresolvedPromises = p.nextUnresolvedPromise;
        p.prevUnresolvedPromise.release();
        p.nextUnresolvedPromise.release();
        unresolvedPromisesUnlocker();
    }

    macro castClosure [c, T] T().{ this.data = c.data; this.fp = c.fp~cast[T.fp~type]; };

    class Promise [ResultType: type] {
        def wkThis: WkRef[Promise[ResultType]];
        def status: Int = Status.NEW;
        def resolver: SrdRef[Resolver[ResultType]];
        def child: ref[ChainNode[ResultType]](nullRef[ChainNode[ResultType]]);
        def prevUnresolvedPromise: SrdRef[Promise[Int]];
        def nextUnresolvedPromise: SrdRef[Promise[Int]];
        def error: SrdRef[Error];
        def result: ResultType;

        handler this.resolve(res: ResultType) {
            if this.status != Status.NEW return;
            removeUnresolvedPromise[ResultType](SrdRef[Promise[ResultType]](this.wkThis));
            this.result = res;
            this.status = Status.RESOLVED;
            def chain: ref[ChainNode[ResultType]](this.child);
            while chain~ptr != 0 {
                // The child may get released during onResolved, so we'll capture its info
                // before the call to avoid access to invalid memory.
                def next: ref[ChainNode[ResultType]](chain.next);
                chain.onResolved(res);
                chain~no_deref = next;
            }
        }

        handler this.resolve(p: SrdRef[Promise[ResultType]]) {
            if this.status != Status.NEW return;
            this.resolver = SrdRef[DirectResolver[ResultType]].construct()~use_in (self){
                promise~no_deref = this;
                chainNode.setPromise(p);
            };
            if p.status == Status.RESOLVED {
                this.resolver.obj~cast[ref[DirectResolver[ResultType]]].chainNode.onResolved(p.result);
            } else if p.status == Status.REJECTED {
                this.resolver.obj~cast[ref[DirectResolver[ResultType]]].chainNode.onRejected(p.error);
            }
        }

        handler this.reject(err: SrdRef[Error]) {
            if this.status != Status.NEW return;
            removeUnresolvedPromise[ResultType](SrdRef[Promise[ResultType]](this.wkThis));
            this.error = err;
            this.status = Status.REJECTED;
            def chain: ref[ChainNode[ResultType]](this.child);
            while chain~ptr != 0 {
                // The child may get released during onRejected, so we'll capture its info
                // before the call to avoid access to invalid memory.
                def next: ref[ChainNode[ResultType]](chain.next);
                chain.onRejected(err);
                chain~no_deref = next;
            }
        }

        function new (): SrdRef[Promise[ResultType]] {
            return SrdRef[Promise[ResultType]]().{
                construct();
                this.wkThis = this;
                addUnresolvedPromise[ResultType](this);
            };
        }

        handler [ThenType: type] this.then(
            cb: closure (input: ResultType, promise: ref[Promise[ThenType]])
        ): SrdRef[Promise[ThenType]] {
            return SrdRef[Promise[ThenType]].construct()~use_in(thenPromise) {
                wkThis = thenPromise;
                resolver = SrdRef[ThenResolver[ThenType, ResultType]].construct()~use_in (self){
                    promise~no_deref = thenPromise.obj;
                    chainNode.setPromise(SrdRef[Promise[ResultType]](this.wkThis));
                    callback = cb;
                };
                if this.status == Status.RESOLVED {
                    resolver.obj~cast[ref[ThenResolver[ThenType, ResultType]]].chainNode.onResolved(this.result);
                } else if this.status == Status.REJECTED {
                    resolver.obj~cast[ref[ThenResolver[ThenType, ResultType]]].chainNode.onRejected(this.error);
                }
                addUnresolvedPromise[ThenType](thenPromise);
            };
        }

        handler [ThenType: type] this.then(
            cb: closure (input: ResultType, promise: ref[ThenPromise[ThenType, ResultType]])
        ): SrdRef[Promise[ThenType]] {
            return this.then[ThenType](castClosure[cb, closure (input: ResultType, promise: ref[Promise[ThenType]])]);
        }

        handler this.catch(
            cb: closure (err: SrdRef[Error], promise: ref[Promise[ResultType]])
        ): SrdRef[Promise[ResultType]] {
            return SrdRef[Promise[ResultType]].construct()~use_in(catchPromise) {
                wkThis = catchPromise;
                resolver = SrdRef[CatchResolver[ResultType]].construct()~use_in(self) {
                    promise~no_deref = catchPromise.obj;
                    chainNode.setPromise(SrdRef[Promise[ResultType]](this.wkThis));
                    callback = cb;
                };
                if this.status == Status.RESOLVED {
                    resolver.obj~cast[ref[CatchResolver[ResultType]]].chainNode.onResolved(this.result);
                } else if this.status == Status.REJECTED {
                    resolver.obj~cast[ref[CatchResolver[ResultType]]].chainNode.onRejected(this.error);
                }
                addUnresolvedPromise[ResultType](catchPromise);
            };
        }

        handler this.catch(
            cb: closure (err: SrdRef[Error], promise: ref[CatchPromise[ResultType]])
        ): SrdRef[Promise[ResultType]] {
            return this.catch(castClosure[cb, closure (err: SrdRef[Error], promise: ref[Promise[ResultType]])]);
        }

        handler this.ignoreResult(): SrdRef[Promise[Int]] {
            return this.then[Int](
                closure (input: ResultType, p: ref[Promise[Int]]) {
                    p.resolve(Int(0));
                }
            );
        }

        function all (inputs: Array[SrdRef[Promise[ResultType]]]): SrdRef[Promise[Array[ResultType]]] {
            return SrdRef[Promise[Array[ResultType]]].construct()~use_in(allPromise) {
                wkThis = allPromise;
                resolver = SrdRef[AllResolver[ResultType]].construct()~use_in(__this) {
                    promise~no_deref = allPromise.obj;
                    def allResolved: Bool = true;
                    def i: Int;
                    for i = 0, i < inputs.getLength(), ++i {
                        chainNodes.add(SrdRef[AllChainNode[ResultType]].construct()~use_in(self){
                            allResolver~no_deref = __this.obj;
                            setPromise(inputs(i));
                        });
                        if chainNodes(i).depPromise.status == Status.RESOLVED {
                            allPromise.result.add(chainNodes(i).depPromise.result);
                        } else {
                            allResolved = false;
                            allPromise.result.add(ResultType());
                            if chainNodes(i).depPromise.status == Status.REJECTED and status == Status.NEW {
                                allPromise.reject(chainNodes(i).depPromise.error);
                            }
                        }
                    }
                    if allResolved allPromise.resolve(result);
                };
                addUnresolvedPromise[Array[ResultType]](allPromise);
            };
        }

        function all (count: Int, inputs: ...SrdRef[Promise[ResultType]]): SrdRef[Promise[Array[ResultType]]] {
            def ar: Array[SrdRef[Promise[ResultType]]];
            while count-- > 0 ar.add(inputs~next_arg[SrdRef[Promise[ResultType]]]);
            return all(ar);
        }
    }

    class ThenPromise [ResultType: type, InputType: type] {
        @injection def promise: Promise[ResultType];

        handler this.retry(p: SrdRef[Promise[InputType]]) {
            if this.resolver.getResolverType() != ResolverType.THEN_RESOLVER return;
            this.resolver.obj~cast[ref[ThenResolver[ResultType, InputType]]].chainNode.setPromise(p);
            if p.status == Status.RESOLVED {
                this.resolver.obj~cast[ref[ThenResolver[ResultType, InputType]]].chainNode.onResolved(p.result);
            } else if p.status == Status.REJECTED {
                this.resolver.obj~cast[ref[ThenResolver[ResultType, InputType]]].chainNode.onRejected(p.error);
            }
        }
    }

    class CatchPromise [ResultType: type] {
        @injection def promise: Promise[ResultType];

        handler this.retry(p: SrdRef[Promise[ResultType]]) {
            if this.resolver.getResolverType() != ResolverType.CATCH_RESOLVER return;
            this.resolver.obj~cast[ref[CatchResolver[ResultType]]].chainNode.setPromise(p);
            if p.status == Status.RESOLVED {
                this.resolver.obj~cast[ref[CatchResolver[ResultType]]].chainNode.onResolved(p.result);
            } else if p.status == Status.REJECTED {
                this.resolver.obj~cast[ref[CatchResolver[ResultType]]].chainNode.onRejected(p.error);
            }
        }
    }

    class ChainNode [InputType: type] {
        def next: ref[ChainNode[InputType]](nullRef[ChainNode[InputType]]);
        def depPromise: SrdRef[Promise[InputType]];
        handler this.setPromise(p: SrdRef[Promise[InputType]]) {
            this.releasePromise();
            this.next~no_deref = p.child;
            p.child~no_deref = this;
            this.depPromise = p;
        }
        handler this.releasePromise() {
            if this.depPromise.isNull() return;
            if this.depPromise.child~ptr == this~ptr {
                this.depPromise.child~no_deref = this.next;
            } else {
                def c: ref[ChainNode[InputType]](this.depPromise.child);
                while c.next~ptr != 0 {
                    if c.next~ptr == this~ptr {
                        c.next~no_deref = this.next;
                        break;
                    }
                    c~no_deref = c.next;
                }
            }
        }
        handler this~terminate() {
            this.releasePromise();
        }
        handler this.onResolved(result: InputType) as_ptr;
        handler this.onRejected(err: SrdRef[Error]) as_ptr;
    }

    def ResolverType: {
        def DIRECT_RESOLVER: 1;
        def THEN_RESOLVER: 2;
        def CATCH_RESOLVER: 3;
        def ALL_RESOLVER: 4;
    };

    class Resolver [ResultType: type] {
        handler this.getResolverType(): Int as_ptr;
        def promise: ref[Promise[ResultType]];
    }

    class DirectResolver [ResultType: type] {
        @injection def resolver: Resolver[ResultType];
        @injection def chainNode: ChainNode[ResultType];
        handler (this: ChainNode[ResultType]).onResolved(result: ResultType) set_ptr {
            unshiftThis[chainNode];
            this.promise.resolve(result);
        }
        handler (this: ChainNode[ResultType]).onRejected(err: SrdRef[Error]) set_ptr {
            unshiftThis[chainNode];
            this.promise.reject(err);
        }
        handler (this:Resolver[ResultType]).getResolverType(): Int set_ptr {
            return ResolverType.DIRECT_RESOLVER;
        }
    }

    class ThenResolver [ResultType: type, InputType: type] {
        @injection def resolver: Resolver[ResultType];
        @injection def chainNode: ChainNode[InputType];
        def callback: closure (input: InputType, promise: ref[Promise[ResultType]]);
        handler (this: ChainNode[InputType]).onResolved(result: InputType) set_ptr {
            unshiftThis[chainNode];
            this.callback(result, this.promise);
        }
        handler (this: ChainNode[InputType]).onRejected(err: SrdRef[Error]) set_ptr {
            unshiftThis[chainNode];
            this.promise.reject(err);
        }
        handler (this:Resolver[ResultType]).getResolverType(): Int set_ptr {
            return ResolverType.THEN_RESOLVER;
        }
    }

    class CatchResolver [InputType: type] {
        @injection def resolver: Resolver[InputType];
        @injection def chainNode: ChainNode[InputType];
        def callback: closure (err: SrdRef[Error], promise: ref[Promise[InputType]]);
        handler (this: ChainNode[InputType]).onResolved(result: InputType) set_ptr {
            unshiftThis[chainNode];
            this.promise.resolve(result);
        }
        handler (this: ChainNode[InputType]).onRejected(err: SrdRef[Error]) set_ptr {
            unshiftThis[chainNode];
            this.callback(err, this.promise);
        }
        handler (this:Resolver[InputType]).getResolverType(): Int set_ptr {
            return ResolverType.CATCH_RESOLVER;
        }
    }

    class AllChainNode [InputType: type] {
        @injection def chainNode: ChainNode[InputType];
        def allResolver: ref[AllResolver[InputType]];
        handler (this: ChainNode[InputType]).onResolved(result: InputType) set_ptr {
            this.allResolver.onResolved(result, this);
        }
        handler (this: ChainNode[InputType]).onRejected(err: SrdRef[Error]) set_ptr {
            this.allResolver.onRejected(err, this);
        }
    }

    class AllResolver [InputType: type] {
        @injection def resolver: Resolver[Array[InputType]];
        def chainNodes: Array[SrdRef[AllChainNode[InputType]]];

        handler this.onResolved(r: InputType, p: ref[AllChainNode[InputType]]) {
            if this.promise.status != Status.NEW return;
            def i: Int;
            def allResolved: Bool = true;
            for i = 0, i < this.chainNodes.getLength(), ++i {
                if this.chainNodes(i).obj~ptr == p~ptr {
                    this.promise.result(i) = r;
                }
                if this.chainNodes(i).depPromise.status != Status.RESOLVED {
                    allResolved = false;
                }
            }
            if allResolved this.promise.resolve(this.promise.result);
        }
        
        handler this.onRejected(err: SrdRef[Error], p: ref[AllChainNode[InputType]]) {
            if this.promise.status != Status.NEW return;
            this.promise.reject(err);
        }
        handler (this:Resolver[Array[InputType]]).getResolverType(): Int set_ptr {
            return ResolverType.ALL_RESOLVER;
        }
    }

    def Status: {
        def NEW: 0;
        def RESOLVED: 1;
        def REJECTED: 2;
    }

    macro unshiftThis[member] {
        this~ptr = (this~ptr~cast[ArchWord] - ptr[this_type](0)~cnt.member~ptr~cast[ArchWord])~cast[ptr[this_type]];
    }
}