/*
 *  Copyright 2016 Anyware Services
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */
package org.ametys.core.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.function.BinaryOperator;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.stream.Collector;

/**
 * Helper for lambda expressions.
 */
public final class LambdaUtils
{
    private LambdaUtils()
    {
        // empty constructor
    }
    
    /**
     * Function allowed to throw checked {@link Exception}. <br>
     * It allows to build one-line lambda for methods throwing checked exceptions.
     * @param <T> the type of the input to the function.
     * @param <R> the type of the result of the function.
     */
    @FunctionalInterface
    public interface ThrowingFunction<T, R>
    {
        /**
         * Applies this function to the given argument.
         * @param t the function argument
         * @return the function result
         * @throws Exception if something wrong occurs.
         */
        R apply(T t) throws Exception;
    }
    
    /**
     * Wraps a {@link Function} by catching its {@link Exception} and rethrowing them as {@link LambdaException}.
     * @param function the {@link Function} to wrap.
     * @param <T> The type of input to the function
     * @param <R> The type of result of the function
     * @return the wrapped {@link Function}.
     */
    public static <T, R> Function<T, R> wrap(ThrowingFunction<T, R> function)
    {
        return value -> 
        {
            try
            {
                return function.apply(value);
            }
            catch (Exception e)
            {
                if (e instanceof RuntimeException)
                {
                    throw (RuntimeException) e;
                }
                
                throw new LambdaException(e);
            }
        };
    }
    
    /**
     * Predicate allowed to throw checked {@link Exception}. <br>
     * It allows to build one-line lambda for methods throwing checked exceptions.
     * @param <T> the type of the input to the predicate.
     */
    @FunctionalInterface
    public interface ThrowingPredicate<T>
    {
        /**
         * Evaluates this predicate on the given argument.
         * @param t the input argument
         * @return {@code true} if the input argument matches the predicate,
         * otherwise {@code false}
         * @throws Exception if something wrong occurs.
         */
        boolean test(T t) throws Exception;
    }
    
    /**
     * Wraps a {@link Predicate} by catching its {@link Exception} and rethrowing them as {@link LambdaException}.
     * @param predicate the {@link Predicate} to wrap.
     * @param <T> the type of the input to the predicate
     * @return the wrapped {@link Predicate}.
     */
    public static <T> Predicate<T> wrapPredicate(ThrowingPredicate<T> predicate)
    {
        return LambdaUtils.wrap(predicate::test)::apply;
        
    }
    
    /**
     * Consumer allowed to throw checked {@link Exception}. <br>
     * It allows to build one-line lambda for methods throwing checked exceptions.
     * @param <T> the type of the input to the operation
     */
    @FunctionalInterface
    public interface ThrowingConsumer<T> extends ThrowingConsumerExceptionAware<T, Exception>
    {
        // Everything is in ThrowingConsumerExceptionAware
    }
    
    /**
     * Consumer allowed to throw checked {@link Exception}. <br>
     * It allows to build one-line lambda for methods throwing checked exceptions.
     * @param <T> the type of the input to the operation
     * @param <E> the type of the exception.
     */
    @FunctionalInterface
    public interface ThrowingConsumerExceptionAware<T, E extends Exception>
    {
        /**
         * Performs this operation on the given argument.
         * @param t the input argument
         * @throws Exception if something wrong occurs.
         */
        void accept(T t) throws E;
    }

    /**
     * Wraps a {@link Consumer} by catching its {@link Exception} and rethrowing them as {@link LambdaException}.
     * @param consumer the {@link Consumer} to wrap.
     * @param <T> The type of input to the operation
     * @return the wrapped {@link Consumer}.
     */
    public static <T> Consumer<T> wrapConsumer(ThrowingConsumer<T> consumer)
    {
        return value -> 
        {
            try
            {
                consumer.accept(value);
            }
            catch (Exception e)
            {
                if (e instanceof RuntimeException)
                {
                    throw (RuntimeException) e;
                }
                
                throw new LambdaException(e);
            }
        };
    }
    
    /**
     * Some useful {@link Collector collectors}
     */
    public static class Collectors
    {
        /**
         * Returns a {@link Collector} that accumulates elements into a
         * {@link LinkedHashMap} whose keys and values are the result of applying the provided
         * mapping functions to the input elements.
         * <br>
         * <br>This is the same as {@link java.util.stream.Collectors#toMap(Function, Function)},
         * but elements are collected into a {@link LinkedHashMap} instead of a {@link HashMap}
         * 
         * @param <T> the type of the input elements
         * @param <K> the output type of the key mapping function
         * @param <U> the output type of the value mapping function
         * @param keyMapper a mapping function to produce keys
         * @param valueMapper a mapping function to produce values
         * @return a {@code Collector} which collects elements into a {@link LinkedHashMap}
         * whose keys and values are the result of applying mapping functions to
         * the input elements
         */
        public static <T, K, U> Collector<T, ?, Map<K, U>> toLinkedHashMap(Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper)
        {
            return java.util.stream.Collectors.toMap(keyMapper, valueMapper, _throwingMerger(), LinkedHashMap::new);
        }
        
        // copied from java.util.stream.Collectors.throwingMerger()
        private static <T> BinaryOperator<T> _throwingMerger()
        {
            return (u, v) ->
            {
                throw new IllegalStateException(String.format("Duplicate key %s", u));
            };
        }
        
        /**
         * A convenient method for creating a {@link Collector} which accumulates elements into a {@link List},
         * this list being transformed by the provided finisher into the final result. 
         * @param <T> the type of the input elements
         * @param <R> the final result type 
         * @param finisher The finisher function for the new collector
         * @return the new collector
         */
        public static <T, R> Collector<T, List<T>, R> withListAccumulation(Function<List<T>, R> finisher)
        {
            return Collector.of(
                ArrayList<T>::new, 
                (res, q) -> res.add(q), 
                (res1, res2) ->
                {
                    res1.addAll(res2);
                    return res1;
                },
                finisher);
        }
    }
    
    /**
     * Some useful {@link BiPredicate biPredicates}
     * @param <T> the type of arguments to the specified bipredicate
     * @param <U> the type of arguments to the specified bipredicate
     */
    public static class BiPredicate<T, U>
    {
        /**
         * Returns a bipredicate that is the negation of the supplied bipredicate.
         * @param <T> the type of arguments to the specified bipredicate
         * @param <U> the type of arguments to the specified bipredicate
         * @param target bipredicate to negate
         * @return a bipredicate that negates the results of the supplied bipredicate
         */
        @SuppressWarnings("unchecked")
        public static <T, U> java.util.function.BiPredicate<T, U> not(java.util.function.BiPredicate<? super T, ? super U> target)
        {
            Objects.requireNonNull(target);
            return (java.util.function.BiPredicate<T, U>) target.negate();
        }
    }
    
    /**
     * Runtime exception wrapping the exception thrown from the lambda
     */
    public static class LambdaException extends RuntimeException
    {
        /** Constructs a new runtime exception with the specified cause and a
         * detail message of {@code (cause==null ? null : cause.toString())}
         * (which typically contains the class and detail message of
         * {@code cause}).  This constructor is useful for runtime exceptions
         * that are little more than wrappers for other throwables.
         *
         * @param  cause the cause (which is saved for later retrieval by the
         *         {@link #getCause()} method).  (A {@code null} value is
         *         permitted, and indicates that the cause is nonexistent or
         *         unknown.)
         */
        public LambdaException(Throwable cause) 
        {
            super(cause);
        }
    }
}