/*
 * The contents of this file are subject to the terms of the Common Development and
 * Distribution License (the License). You may not use this file except in compliance with the
 * License.
 *
 * You can obtain a copy of the License at legal/CDDLv1.0.txt. See the License for the
 * specific language governing permission and limitations under the License.
 *
 * When distributing Covered Software, include this CDDL Header Notice in each file and include
 * the License file at legal/CDDLv1.0.txt. If applicable, add the following below the CDDL
 * Header, with the fields enclosed by brackets [] replaced by your own identifying
 * information: "Portions copyright [year] [name of copyright owner]".
 *
 * Copyright 2015-2016 ForgeRock AS.
 */

package org.forgerock.util.promise;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;

import org.forgerock.util.AsyncFunction;
import org.forgerock.util.Function;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Utility methods for creating and composing {@link Promise}s.
 */
public final class Promises {
    // TODO: n-of, etc.

    /**
     * These completed promise implementations provide an optimization for
     * synchronous processing, which have been found to provide small but
     * significant benefit:
     *
     * <ul>
     *     <li>A small reduction in GC overhead (less frequent GCs = more
     *     deterministic response times)</li>
     *     <li>A reduction of the cost associated with calling then() on a
     *     pre-completed promise versus the implementation in
     *     org.forgerock.util.promise.PromiseImpl#then(Function, Function).
     *     Specifically, a reduction in two volatile accesses as well as memory
     *     again.</li>
     * </ul>
     *
     * @param <V> {@inheritDoc}
     * @param <E> {@inheritDoc}
     */
    private static abstract class CompletedPromise<V, E extends Exception> implements Promise<V, E> {

        private static final Logger LOGGER = LoggerFactory.getLogger(CompletedPromise.class);

        @Override
        public final boolean cancel(final boolean mayInterruptIfRunning) {
            return false;
        }

        @Override
        public final V get() throws ExecutionException {
            if (hasResult()) {
                return getResult();
            } else if (hasException()) {
                throw new ExecutionException(getException());
            } else {
                throw new ExecutionException(getRuntimeException());
            }
        }

        @Override
        public final V get(final long timeout, final TimeUnit unit) throws ExecutionException {
            return get();
        }

        @Override
        public final V getOrThrow() throws E {
            if (hasResult()) {
                return getResult();
            } else if (hasException()) {
                throw getException();
            } else {
                throw getRuntimeException();
            }
        }

        @Override
        public final V getOrThrow(final long timeout, final TimeUnit unit) throws E {
            return getOrThrow();
        }

        @Override
        public final V getOrThrowUninterruptibly() throws E {
            return getOrThrow();
        }

        @Override
        public final V getOrThrowUninterruptibly(final long timeout, final TimeUnit unit) throws E {
            return getOrThrow();
        }

        @Override
        public final boolean isCancelled() {
            return false;
        }

        @Override
        public final boolean isDone() {
            return true;
        }

        @Override
        public final Promise<V, E> thenOnException(final ExceptionHandler<? super E> onException) {
            if (hasException()) {
                try {
                    onException.handleException(getException());
                } catch (RuntimeException e) {
                    LOGGER.error("Ignored unexpected exception thrown by ExceptionHandler", e);
                }
            }
            return this;
        }

        @Override
        public final Promise<V, E> thenOnResult(final ResultHandler<? super V> onResult) {
            if (hasResult()) {
                try {
                    onResult.handleResult(getResult());
                } catch (RuntimeException e) {
                    LOGGER.error("Ignored unexpected exception thrown by ResultHandler", e);
                }
            }
            return this;
        }

        @Override
        public final Promise<V, E> thenOnResultOrException(final ResultHandler<? super V> onResult,
                final ExceptionHandler<? super E> onException) {
            return thenOnResult(onResult).thenOnException(onException);
        }

        @Override
        public final Promise<V, E> thenOnResultOrException(final Runnable onResultOrException) {
            if (hasResult() || hasException()) {
                try {
                    onResultOrException.run();
                } catch (RuntimeException e) {
                    LOGGER.error("Ignored unexpected exception thrown by Runnable", e);
                }
            }
            return this;
        }

        @Override
        public final <VOUT> Promise<VOUT, E> then(final Function<? super V, VOUT, E> onResult) {
            return then(onResult, Promises.<VOUT, E>exceptionIdempotentFunction());
        }

        @Override
        public <EOUT extends Exception> Promise<V, EOUT> thenCatch(Function<? super E, V, EOUT> onException) {
            return then(Promises.<V, EOUT>resultIdempotentFunction(), onException);
        }

        @Override
        public Promise<V, E> thenCatchRuntimeException(
                Function<? super RuntimeException, V, E> onRuntimeException) {
            return then(Promises.<V, E>resultIdempotentFunction(), Promises.<V, E>exceptionIdempotentFunction(),
                    onRuntimeException);
        }

        @Override
        public final <VOUT, EOUT extends Exception> Promise<VOUT, EOUT> then(
                final Function<? super V, VOUT, EOUT> onResult,
                final Function<? super E, VOUT, EOUT> onException) {
            return then(onResult, onException, Promises.<VOUT, EOUT>runtimeExceptionIdempotentFunction());
        }

        @Override
        @SuppressWarnings("unchecked")
        public final <VOUT, EOUT extends Exception> Promise<VOUT, EOUT> then(
                final Function<? super V, VOUT, EOUT> onResult,
                final Function<? super E, VOUT, EOUT> onException,
                final Function<? super RuntimeException, VOUT, EOUT> onRuntimeException) {
            try {
                if (hasResult()) {
                    return newResultPromise(onResult.apply(getResult()));
                } else if (hasException()) {
                    return newResultPromise(onException.apply(getException()));
                } else if (hasRuntimeException()) {
                    return newResultPromise(onRuntimeException.apply(getRuntimeException()));
                } else {
                    throw new IllegalStateException("Unexpected state");
                }
            } catch (final RuntimeException e) {
                return new RuntimeExceptionPromise<>(e);
            } catch (final Exception e) {
                return newExceptionPromise((EOUT) e);
            }
        }

        @Override
        public final Promise<V, E> thenAlways(final Runnable always) {
            try {
                always.run();
            } catch (RuntimeException e) {
                LOGGER.error("Ignored unexpected exception thrown by Runnable", e);
            }
            return this;
        }

        @Override
        public Promise<V, E> thenFinally(Runnable onFinally) {
            return thenAlways(onFinally);
        }

        @Override
        public final <VOUT> Promise<VOUT, E> thenAsync(
                final AsyncFunction<? super V, VOUT, E> onResult) {
            return thenAsync(onResult, Promises.<VOUT, E>exceptionIdempotentAsyncFunction());
        }

        @Override
        public final <EOUT extends Exception> Promise<V, EOUT> thenCatchAsync(
                final AsyncFunction<? super E, V, EOUT> onException) {
            return thenAsync(Promises.<V, EOUT>resultIdempotentAsyncFunction(), onException);
        }

        @Override
        public Promise<V, E> thenCatchRuntimeExceptionAsync(
                AsyncFunction<? super RuntimeException, V, E> onRuntimeException) {
            return thenAsync(Promises.<V, E>resultIdempotentAsyncFunction(),
                    Promises.<V, E>exceptionIdempotentAsyncFunction(),
                    onRuntimeException);
        }

        @Override
        public final <VOUT, EOUT extends Exception> Promise<VOUT, EOUT> thenAsync(
                final AsyncFunction<? super V, VOUT, EOUT> onResult,
                final AsyncFunction<? super E, VOUT, EOUT> onException) {
            return thenAsync(onResult, onException, Promises.<VOUT, EOUT>runtimeExceptionIdempotentAsyncFunction());
        }

        @Override
        @SuppressWarnings("unchecked")
        public final <VOUT, EOUT extends Exception> Promise<VOUT, EOUT> thenAsync(
                final AsyncFunction<? super V, VOUT, EOUT> onResult,
                final AsyncFunction<? super E, VOUT, EOUT> onException,
                final AsyncFunction<? super RuntimeException, VOUT, EOUT> onRuntimeException) {
            try {
                if (hasResult()) {
                    return (Promise<VOUT, EOUT>) onResult.apply(getResult());
                } else if (hasException()) {
                    return (Promise<VOUT, EOUT>) onException.apply(getException());
                } else if (hasRuntimeException()) {
                    return (Promise<VOUT, EOUT>) onRuntimeException.apply(getRuntimeException());
                } else {
                    throw new IllegalStateException("Unexpected state");
                }
            } catch (final RuntimeException e) {
                return new RuntimeExceptionPromise<>(e);
            } catch (final Exception e) {
                return newExceptionPromise((EOUT) e);
            }
        }

        @Override
        public Promise<V, E> thenOnRuntimeException(RuntimeExceptionHandler onRuntimeException) {
            if (getRuntimeException() != null) {
                try {
                    onRuntimeException.handleRuntimeException(getRuntimeException());
                } catch (RuntimeException e) {
                    LOGGER.error("Ignored unexpected exception thrown by RuntimeExceptionHandler", e);
                }
            }
            return this;
        }

        abstract RuntimeException getRuntimeException();

        abstract E getException();

        abstract V getResult();

        abstract boolean hasRuntimeException();

        abstract boolean hasException();

        abstract boolean hasResult();
    }

    private static final class RuntimeExceptionPromise<V, E extends Exception> extends CompletedPromise<V, E> {
        private final RuntimeException runtimeException;

        private RuntimeExceptionPromise(RuntimeException runtimeException) {
            this.runtimeException = runtimeException;
        }

        @Override
        RuntimeException getRuntimeException() {
            return runtimeException;
        }

        @Override
        E getException() {
            return null;
        }

        @Override
        V getResult() {
            return null;
        }

        @Override
        boolean hasRuntimeException() {
            return true;
        }

        @Override
        boolean hasException() {
            return false;
        }

        @Override
        boolean hasResult() {
            return false;
        }
    }

    private static final class ExceptionPromise<V, E extends Exception> extends CompletedPromise<V, E> {
        private final E exception;

        private ExceptionPromise(final E exception) {
            this.exception = exception;
        }

        @Override
        RuntimeException getRuntimeException() {
            return null;
        }

        @Override
        E getException() {
            return exception;
        }

        @Override
        V getResult() {
            throw new IllegalStateException();
        }

        @Override
        boolean hasRuntimeException() {
            return false;
        }

        @Override
        boolean hasException() {
            return true;
        }

        @Override
        boolean hasResult() {
            return false;
        }
    }

    private static final class ResultPromise<V, E extends Exception> extends
            CompletedPromise<V, E> {
        private final V value;

        private ResultPromise(final V value) {
            this.value = value;
        }

        @Override
        RuntimeException getRuntimeException() {
            return null;
        }

        @Override
        E getException() {
            throw new IllegalStateException();
        }

        @Override
        V getResult() {
            return value;
        }

        @Override
        boolean hasRuntimeException() {
            return false;
        }

        @Override
        boolean hasException() {
            return false;
        }

        @Override
        boolean hasResult() {
            return true;
        }
    }

    private static final AsyncFunction<Exception, Object, Exception> EXCEPTION_IDEM_ASYNC_FUNC =
        new AsyncFunction<Exception, Object, Exception>() {
            @Override
            public Promise<Object, Exception> apply(final Exception exception) throws Exception {
                return newExceptionPromise(exception);
            }
        };

    private static final Function<Exception, Object, Exception> EXCEPTION_IDEM_FUNC =
        new Function<Exception, Object, Exception>() {
            @Override
            public Object apply(final Exception exception) throws Exception {
                throw exception;
            }
        };

    private static final AsyncFunction<RuntimeException, Object, Exception> RUNTIME_EXCEPTION_IDEM_ASYNC_FUNC =
        new AsyncFunction<RuntimeException, Object, Exception>() {
            @Override
            public Promise<Object, Exception> apply(final RuntimeException runtimeException) throws Exception {
                return newRuntimeExceptionPromise(runtimeException);
            }
        };

    private static final Function<RuntimeException, Object, Exception> RUNTIME_EXCEPTION_IDEM_FUNC =
        new Function<RuntimeException, Object, Exception>() {
            @Override
            public Object apply(final RuntimeException runtimeException) {
                throw runtimeException;
            }
        };

    private static final AsyncFunction<Object, Object, Exception> RESULT_IDEM_ASYNC_FUNC =
        new AsyncFunction<Object, Object, Exception>() {
            @Override
            public Promise<Object, Exception> apply(final Object object) throws Exception {
                return newResultPromise(object);
            }
        };

    private static final Function<Object, Object, Exception> RESULT_IDEM_FUNC =
        new Function<Object, Object, Exception>() {
            @Override
            public Object apply(final Object value) throws Exception {
                return value;
            }
        };

    /**
     * Returns a {@link Promise} representing an asynchronous task which has
     * already failed with the provided runtime exception. Attempts to get the result will
     * immediately fail, and any listeners registered against the returned
     * promise will be immediately invoked in the same thread as the caller.
     *
     * @param <V>
     *            The type of the task's result, or {@link Void} if the task
     *            does not return anything (i.e. it only has side-effects).
     * @param <E>
     *            The type of the exception thrown by the task if it fails, or
     *            {@link NeverThrowsException} if the task cannot fail.
     * @param exception
     *            The exception indicating why the asynchronous task has failed.
     * @return A {@link Promise} representing an asynchronous task which has
     *         already failed with the provided exception.
     */
    public static <V, E extends Exception> Promise<V, E> newRuntimeExceptionPromise(final RuntimeException exception) {
        return new RuntimeExceptionPromise<>(exception);
    }

    /**
     * Returns a {@link Promise} representing an asynchronous task which has
     * already failed with the provided exception. Attempts to get the result will
     * immediately fail, and any listeners registered against the returned
     * promise will be immediately invoked in the same thread as the caller.
     *
     * @param <V>
     *            The type of the task's result, or {@link Void} if the task
     *            does not return anything (i.e. it only has side-effects).
     * @param <E>
     *            The type of the exception thrown by the task if it fails, or
     *            {@link NeverThrowsException} if the task cannot fail.
     * @param exception
     *            The exception indicating why the asynchronous task has failed.
     * @return A {@link Promise} representing an asynchronous task which has
     *         already failed with the provided exception.
     */
    public static <V, E extends Exception> Promise<V, E> newExceptionPromise(final E exception) {
        return new ExceptionPromise<>(exception);
    }

    /**
     * Returns a {@link Promise} representing an asynchronous task which has
     * already succeeded with the provided result. Attempts to get the result
     * will immediately return the result, and any listeners registered against
     * the returned promise will be immediately invoked in the same thread as
     * the caller.
     *
     * @param <V>
     *            The type of the task's result, or {@link Void} if the task
     *            does not return anything (i.e. it only has side-effects).
     * @param <E>
     *            The type of the exception thrown by the task if it fails, or
     *            {@link NeverThrowsException} if the task cannot fail.
     * @param result
     *            The result of the asynchronous task.
     * @return A {@link Promise} representing an asynchronous task which has
     *         already succeeded with the provided result.
     */
    public static <V, E extends Exception> Promise<V, E> newResultPromise(final V result) {
        return new ResultPromise<>(result);
    }

    /**
     * Returns a {@link Promise} which will be completed once all of the
     * provided promises have succeeded, or as soon as one of them fails.
     *
     * @param <V>
     *            The type of the tasks' result, or {@link Void} if the tasks do
     *            not return anything (i.e. they only has side-effects).
     * @param <E>
     *            The type of the exception thrown by the tasks if they fail, or
     *            {@link NeverThrowsException} if the tasks cannot fail.
     * @param promises
     *            The list of tasks to be combined.
     * @return A {@link Promise} which will be completed once all of the
     *         provided promises have succeeded, or as soon as one of them
     *         fails.
     */
    public static <V, E extends Exception> Promise<List<V>, E> when(
            final List<Promise<V, E>> promises) {
        final int size = promises.size();
        final AtomicInteger remaining = new AtomicInteger(size);
        final List<V> results = new ArrayList<>(size);
        final PromiseImpl<List<V>, E> composite = PromiseImpl.create();
        for (final Promise<V, E> promise : promises) {
            promise.thenOnResult(new ResultHandler<V>() {
                @Override
                public void handleResult(final V value) {
                    synchronized (results) {
                        results.add(value);
                    }
                    if (remaining.decrementAndGet() == 0) {
                        composite.handleResult(results);
                    }
                }
            })  .thenOnException(new ExceptionHandler<E>() {
                @Override
                public void handleException(final E exception) {
                    composite.handleException(exception);
                }
            })  .thenOnRuntimeException(new RuntimeExceptionHandler() {
                @Override
                public void handleRuntimeException(RuntimeException exception) {
                    composite.handleRuntimeException(exception);
                }
            });
        }
        if (promises.isEmpty()) {
            composite.handleResult(results);
        }
        return composite;
    }

    /**
     * Returns a {@link Promise} which will be completed once all of the
     * provided promises have succeeded, or as soon as one of them fails.
     *
     * @param <V>
     *            The type of the tasks' result, or {@link Void} if the tasks do
     *            not return anything (i.e. they only has side-effects).
     * @param <E>
     *            The type of the exception thrown by the tasks if they fail, or
     *            {@link NeverThrowsException} if the tasks cannot fail.
     * @param promises
     *            The list of tasks to be combined.
     * @return A {@link Promise} which will be completed once all of the
     *         provided promises have succeeded, or as soon as one of them
     *         has thrown an exception.
     */
    @SafeVarargs
    public static <V, E extends Exception> Promise<List<V>, E> when(final Promise<V, E>... promises) {
        return when(Arrays.asList(promises));
    }

    @SuppressWarnings("unchecked")
    static <VOUT, E extends Exception> AsyncFunction<E, VOUT, E> exceptionIdempotentAsyncFunction() {
        return (AsyncFunction<E, VOUT, E>) EXCEPTION_IDEM_ASYNC_FUNC;
    }

    @SuppressWarnings("unchecked")
    static <VOUT, E extends Exception> Function<E, VOUT, E> exceptionIdempotentFunction() {
        return (Function<E, VOUT, E>) EXCEPTION_IDEM_FUNC;
    }

    @SuppressWarnings("unchecked")
    static <VOUT, E extends Exception> AsyncFunction<RuntimeException, VOUT, E>
        runtimeExceptionIdempotentAsyncFunction() {
        return (AsyncFunction<RuntimeException, VOUT, E>) RUNTIME_EXCEPTION_IDEM_ASYNC_FUNC;
    }

    @SuppressWarnings("unchecked")
    static <VOUT, E extends Exception> Function<RuntimeException, VOUT, E> runtimeExceptionIdempotentFunction() {
        return (Function<RuntimeException, VOUT, E>) RUNTIME_EXCEPTION_IDEM_FUNC;
    }

    @SuppressWarnings("unchecked")
    static <V, E extends Exception> AsyncFunction<V, V, E> resultIdempotentAsyncFunction() {
        return (AsyncFunction<V, V, E>) RESULT_IDEM_ASYNC_FUNC;
    }

    @SuppressWarnings("unchecked")
    static <V, E extends Exception> Function<V, V, E> resultIdempotentFunction() {
        return (Function<V, V, E>) RESULT_IDEM_FUNC;
    }

    private Promises() {
        // Prevent instantiation.
    }
}