using System;
using System.Reflection;
using Implab.Parallels;

namespace Implab {
    public class Promise<T> : AbstractEvent<IResolvable<T>>, IPromise<T> {

        class ResolvableSignal : IResolvable<T> {
            public Signal Signal { get; private set; }
            public ResolvableSignal() {
                Signal = new Signal();
            }


            public void Reject(Exception error) {
                Signal.Set();
            }

            public void Resolve(T result) {
                Signal.Set();
            }
        }

        class ResolvableWrapper : IResolvable<T> {
            readonly IResolvable m_resolvable;
            public ResolvableWrapper(IResolvable resolvable) {
                m_resolvable = resolvable;
            }

            public void Reject(Exception reason) {
                m_resolvable.Reject(reason);
            }

            public void Resolve(T value) {
                m_resolvable.Resolve();
            }
        }

        PromiseState m_state;

        T m_result;

        Exception m_error;

        public bool IsRejected {
            get {
                return m_state == PromiseState.Rejected;
            }
        }

        public bool IsFulfilled {
            get {
                return m_state == PromiseState.Fulfilled;
            }
        }

        public Exception RejectReason {
            get {
                return m_error;
            }
        }


        internal void ResolvePromise(T result) {
            if (BeginTransit()) {
                m_result = result;
                m_state = PromiseState.Fulfilled;
                CompleteTransit();
            }
        }

        internal void RejectPromise(Exception reason) {
            if (BeginTransit()) {
                m_error = reason;
                m_state = PromiseState.Rejected;
                CompleteTransit();
            }
        }


        #region implemented abstract members of AbstractPromise

        protected override void SignalHandler(IResolvable<T> handler) {
            switch (m_state) {
                case PromiseState.Fulfilled:
                    handler.Resolve(m_result);
                    break;
                case PromiseState.Rejected:
                    handler.Reject(RejectReason);
                    break;
                default:
                    throw new InvalidOperationException(String.Format("Invalid promise signal: {0}", m_state));
            }
        }

        protected void WaitResult(int timeout) {
            if (!(IsResolved || GetFulfillSignal().Wait(timeout)))
                throw new TimeoutException();
        }

        protected Signal GetFulfillSignal() {
            var next = new ResolvableSignal();
            Then(next);
            return next.Signal;
        }

        #endregion

        public Type ResultType {
            get {
                return typeof(void);
            }
        }


        protected void Rethrow() {
            if (m_error is OperationCanceledException)
                throw new OperationCanceledException("Operation cancelled", m_error);
            else
                throw new TargetInvocationException(m_error);
        }

        public void Then(IResolvable<T> next) {
            AddHandler(next);
        }

        public void Then(IResolvable next) {
            AddHandler(new ResolvableWrapper(next));
        }

        public IPromise<T2> Cast<T2>() {
            return (IPromise<T2>)this;
        }

        void IPromise.Join() {
            Join();
        }

        void IPromise.Join(int timeout) {
            Join(timeout);
        }

        public T Join() {
            WaitResult(-1);
            if (IsRejected)
                Rethrow();
            return m_result;
        }

        public T Join(int timeout) {
            WaitResult(timeout);
            if (IsRejected)
                Rethrow();
            return m_result;
        }
    }
}