/*
 *  Copyright 2019 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.runtime.util;

import java.lang.annotation.Annotation;
import java.lang.annotation.Inherited;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.apache.commons.lang3.tuple.Pair;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * Helper for {@link Annotation}s.
 */
public final class Annotations
{
    private static final Logger __LOGGER = LoggerFactory.getLogger(Annotations.class);
    
    private Annotations()
    {
        // empty constructor
    }
    
    /**
     * Tests if given {@link Annotation} is present on any of the superclasses or on any of the implemented interfaces.
     * <br>Unlike {@link Class#isAnnotationPresent}, it also checks into all the implemented interfaces.
     * <br> Thus, the meta-annotation {@link Inherited} has no effect because whether or not it is present, the whole hierarchy is traversed here anyway.
     * @param classToTest The class to test
     * @param annotationClass The {@link Annotation} class
     * @return <code>true</code> if annotation is present on any of the superclasses or on any of the implemented interfaces.
     */
    public static boolean isAnnotationPresent(Class<?> classToTest, Class<? extends Annotation> annotationClass)
    {
        if (__LOGGER.isDebugEnabled())
        {
            __LOGGER.debug("[BEGIN] Test if annotation {} is present for {}", annotationClass.getName(), classToTest.getName());
        }
        try
        {
            return _isAnnotationPresent(classToTest, annotationClass) || _isAnnotationPresentOnInterfacesOfSuperclasses(classToTest, annotationClass);
        }
        finally
        {
            if (__LOGGER.isDebugEnabled())
            {
                __LOGGER.debug("[END] Test if annotation {} is present for {} done", annotationClass.getName(), classToTest.getName());
            }
        }
    }
    
    private static boolean _isAnnotationPresent(Class<?> classToTest, Class<? extends Annotation> annotationClass)
    {
        boolean result = classToTest.isAnnotationPresent(annotationClass);
        if (result && __LOGGER.isDebugEnabled())
        {
            String additionalText = classToTest.isInterface() ? "" : "(or on one of its ancestors)";
            __LOGGER.debug("[FOUND] annotation {} is present on {} {}", annotationClass.getName(), classToTest.getName(), additionalText);
        }
        return result;
    }
    
    private static boolean _isAnnotationPresentOnInterfacesOfSuperclasses(Class<?> classToTest, Class<? extends Annotation> annotationClass)
    {
        return _getSuperclassesAndSelf(classToTest)
                .anyMatch(superclass -> _isAnnotationPresentOnInterfaces(superclass, annotationClass));
    }
    
    private static Stream<Class<?>> _getSuperclassesAndSelf(Class<?> classToTest)
    {
        if (classToTest == null 
            || classToTest == Object.class /* optimization */)
        {
            return Stream.empty();
        }
        else
        {
            __LOGGER.debug("found class {}", classToTest.getName());
            return Stream.concat(
                    Stream.of(classToTest), 
                    _getSuperclassesAndSelf(classToTest.getSuperclass()));
        }
    }
    
    private static boolean _isAnnotationPresentOnInterfaces(Class<?> classToTest, Class<? extends Annotation> annotationClass)
    {
        return _getAncestorInterfacesAndSelf(classToTest)
                .anyMatch(theInterface -> _isAnnotationPresent(theInterface, annotationClass));
    }
    
    private static Stream<Class<?>> _getAncestorInterfacesAndSelf(Class<?> classToTest)
    {
        return Stream.concat(
                Stream.of(classToTest), 
                _getAncestorInterfaces(classToTest));
    }
    
    private static Stream<Class<?>> _getAncestorInterfaces(Class<?> classToTest)
    {
        return _getInterfaces(classToTest)
                .map(Annotations::_getAncestorInterfacesAndSelf)
                .flatMap(Function.identity());
    }
    
    private static Stream<Class<?>> _getInterfaces(Class<?> classToTest)
    {
        Class< ? >[] interfaces = classToTest.getInterfaces();
        if (__LOGGER.isDebugEnabled())
        {
            __LOGGER.debug("found interfaces {}", Stream.of(interfaces)
                    .map(Class::getName)
                    .collect(Collectors.toList()));
        }
        return Stream.of(interfaces);
    }
    
    /**
     * Gets the {@link Annotation}s on any of the superclasses or on any of the implemented interfaces from the given class to test, and then apply
     * a {@link BiFunction bifunction} on it (generally to obtain attributes from the {@link Annotation} instance).
     * <br>Unlike {@link Class#getAnnotation}, it also checks into all the implemented interfaces.
     * <br> Whereas the whole hierarchy is traversed, the meta-annotation {@link Inherited} can have some effects depending on
     * the operations you process on the result {@link Stream}, as the same annotation instance will be provided to the {@link BiFunction}
     * with different classes (which are related, one being the superclass of all the others).
     * @param <A> The runtime type of the {@link Annotation}
     * @param <T> The type of results to get
     * @param classToTest The class to test
     * @param annotationClass The {@link Annotation} class
     * @param annotationAttributeGetter The {@link BiFunction two-args function} to apply to get the final results. The two arguments
     * represent the {@link Annotation} instance and the class which is annotated (be careful if the {@link Annotation} class has the meta-annotation {@link Inherited}).
     * @return a {@link Stream} of T elements returned by the {@link BiFunction bifunction} applied on {@link Annotation}s instances 
     * on any of the superclasses or on any of the implemented interfaces or on the provided class itself.
     */
    public static <A extends Annotation, T> Stream<T> getAnnotationAttributeValues(
            Class<?> classToTest, 
            Class<A> annotationClass, 
            BiFunction<A, Class<?>, T> annotationAttributeGetter)
    {
        return _getSuperclassesAndSelf(classToTest)
                .flatMap(Annotations::_getAncestorInterfacesAndSelf)
                .map(classOrInterface -> Pair.of(classOrInterface.getAnnotation(annotationClass), classOrInterface))
                .filter(annotationAndClass -> annotationAndClass.getLeft() != null) // annotation must be present
                .map(annotationAndClass -> _logAndGet(annotationAttributeGetter, annotationAndClass.getRight(), annotationAndClass.getLeft()));
    }
    
    private static <A extends Annotation, T> T _logAndGet(BiFunction<A, Class<?>, T> annotationAttributeGetter, Class<?> annotated, A annotation)
    {
        T result = annotationAttributeGetter.apply(annotation, annotated);
        if (__LOGGER.isDebugEnabled())
        {
            __LOGGER.debug("value '{}' retrieved from {}", result, annotated.getName());
        }
        return result;
    }
}