using System;

​

//https://github.com/timcassell/ProtoPromise#promise-types

​

​

namespace Demo

{

    public class Promise<PromisedT>

    {

        private enum Status

        {

            PENDING,

            RESOLVED,

            REJECTED

        }

​

        private Status status;

        private PromisedT value;

        private Action<PromisedT> onResolved;

        private Action<string> onRejected;

        public Promise()

        {

            status = Status.PENDING;

            value = default(PromisedT);

        }

​

        /// <summary>

        /// Successfully settle the promise

        /// </summary>

        /// <param name = "successValue">The return value of the promise</param>

        public void Resolve(PromisedT successValue)

        {

            if (status == Status.PENDING)

            {

                status = Status.RESOLVED;

                value = successValue;

                onResolved?.Invoke(value);

            }

        }

​

        /// <summary>

        /// Settle the promise to rejection state

        /// </summary>

        public void Reject()

        {

            Reject("Default promise rejection message");

        }

​

        /// <summary>

        /// Settle the promise, reporting an error

        /// </summary>

        /// <param name = "message">The error message</param>

        public void Reject(string message)

        {

            if (status == Status.PENDING)

            {

                status = Status.REJECTED;

                onRejected?.Invoke(message);

            }

        }

​

        // callback doesn't take any args

        public Promise<PromisedT> Catch(Action callback)

        {

            return Catch((msg) => callback());

        }

​

        // callback takes error message as parameter

        public Promise<PromisedT> Catch(Action<string> callback)

        {

            Promise<PromisedT> promise = new Promise<PromisedT>();

            if (status == Status.PENDING)

            {

                onResolved = (PromisedT val) => promise.Resolve(val);

                onRejected = callback;

            }

            else if (status == Status.RESOLVED)

                promise.Resolve(value);

            else

                callback("Default promise rejection message");

            return promise;

        }

​

        // callback doesn't take any args or return anything

        public Promise<bool> Then(Action callback)

        {

            return Then((PromisedT val) =>

            {

                callback();

                return true;

            });

        }

​

        // callback doesn't return anything

        public Promise<bool> Then(Action<PromisedT> callback)

        {

            return Then((PromisedT val) =>

            {

                callback(val);

                return true;

            });

        }

​

        // callback returns value but is not async

        public Promise<ConvertT> Then<ConvertT>(Func<PromisedT, ConvertT> callback)

        {

            Promise<ConvertT> promise = new Promise<ConvertT>();

            Action<PromisedT> initPromiseResolution = (PromisedT val) =>

            {

                ConvertT callbackValue = callback(val);

                promise.Resolve(callbackValue);

            };

            if (status == Status.PENDING)

            {

                onResolved = initPromiseResolution;

                onRejected = (string msg) => promise.Reject(msg);

            }

            else if (status == Status.RESOLVED)

                initPromiseResolution(value);

            else

                promise.Reject();

            return promise;

        }

​

        // callback is async - returns a promise

        public Promise<ConvertT> Then<ConvertT>(Func<PromisedT, Promise<ConvertT>> callback)

        {

            Promise<ConvertT> promise = new Promise<ConvertT>();

            Action<PromisedT> initPromiseResolution = (PromisedT val) =>

            {

                Promise<ConvertT> callbackPromise = callback(val);

                callbackPromise.Then((ConvertT callbackVal) => promise.Resolve(callbackVal));

            };

            if (status == Status.PENDING)

            {

                onResolved = initPromiseResolution;

                onRejected = (string msg) => promise.Reject(msg);

            }

            else if (status == Status.RESOLVED)

                initPromiseResolution(value);

            else

                promise.Reject();

            return promise;

        }

    }

​

    public class Program

    {

        public static void Main()

        {

            Promise<string> promise = new Promise<string>();

            promise.Resolve("true");

            promise.Then(r => System.Console.Write(r));

        }

    }

}