/**
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements. See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership. The ASF licenses this file
 * to you 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.apache.cxf.jaxrs.utils;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.logging.Logger;

import javax.ws.rs.BeanParam;
import javax.ws.rs.Consumes;
import javax.ws.rs.CookieParam;
import javax.ws.rs.DefaultValue;
import javax.ws.rs.FormParam;
import javax.ws.rs.HeaderParam;
import javax.ws.rs.HttpMethod;
import javax.ws.rs.MatrixParam;
import javax.ws.rs.NameBinding;
import javax.ws.rs.Path;
import javax.ws.rs.PathParam;
import javax.ws.rs.Priorities;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.Context;

import org.apache.cxf.Bus;
import org.apache.cxf.common.logging.LogUtils;
import org.apache.cxf.common.util.ClassHelper;

public final class AnnotationUtils {
    private static final Logger LOG = LogUtils.getL7dLogger(AnnotationUtils.class);
    private static final Class<? extends Annotation> PRIORITY_API =
            (Class<? extends Annotation>) loadClassOrNull("javax.annotation.Priority");
    private static final Method PRIORITY_VALUE = getMethodOrNull(PRIORITY_API, "value");

    private static final Set<Class<?>> PARAM_ANNOTATION_CLASSES;
    private static final Set<Class<?>> METHOD_ANNOTATION_CLASSES;
    static {
        PARAM_ANNOTATION_CLASSES = initParamAnnotationClasses();
        METHOD_ANNOTATION_CLASSES = initMethodAnnotationClasses();
    }

    private AnnotationUtils() {

    }

    private static Method getMethodOrNull(final Class<?> type, final String name) {
        if (type == null) {
            return null;
        }
        try {
            return type.getMethod(name);
        } catch (final NoSuchMethodException e) {
            return null;
        }
    }

    private static Class<? extends Annotation> loadClassOrNull(final String name) {
        try {
            return org.apache.cxf.common.classloader.ClassLoaderUtils.loadClass(
                    name, AnnotationUtils.class, Annotation.class);
        } catch (final ClassNotFoundException e) {
            return null;
        }
    }

    private static Set<Class<?>> initParamAnnotationClasses() {
        Set<Class<?>> classes = new HashSet<>();
        classes.add(PathParam.class);
        classes.add(QueryParam.class);
        classes.add(MatrixParam.class);
        classes.add(HeaderParam.class);
        classes.add(CookieParam.class);
        classes.add(FormParam.class);
        classes.add(BeanParam.class);
        return classes;
    }

    private static Set<Class<?>> initMethodAnnotationClasses() {
        Set<Class<?>> classes = new HashSet<>();
        classes.add(HttpMethod.class);
        classes.add(Path.class);
        classes.add(Produces.class);
        classes.add(Consumes.class);
        return classes;
    }

    public static int getBindingPriority(Class<?> providerCls) {
        if (PRIORITY_API == null) {
            return Priorities.USER;
        }
        Annotation b = getClassAnnotation(providerCls, PRIORITY_API);
        try {
            return b == null ? Priorities.USER : Integer.class.cast(PRIORITY_VALUE.invoke(b));
        } catch (final IllegalAccessException | InvocationTargetException e) {
            return Priorities.USER;
        }
    }
    
    public static Set<String> getInstanceNameBindings(Bus bus, Object obj) {
        final Class<?> realClazz = ClassHelper.getRealClass(bus, obj);
        return getNameBindings(realClazz.getAnnotations());
    }
    
    public static Set<String> getNameBindings(Bus bus, Class<?> clazz) {
        final Class<?> realClazz = ClassHelper.getRealClassFromClass(bus, clazz);
        return getNameBindings(realClazz.getAnnotations());
    }
    
    public static Set<String> getNameBindings(Annotation[] targetAnns) {
        if (targetAnns.length == 0) {
            return Collections.emptySet();
        }
        Set<String> names = new LinkedHashSet<>();
        for (Annotation a : targetAnns) {
            NameBinding nb = a.annotationType().getAnnotation(NameBinding.class);
            if (nb != null) {
                names.add(a.annotationType().getName());
            }
        }
        return names;
    }

    public static boolean isParamAnnotationClass(Class<?> annotationClass) {
        return PARAM_ANNOTATION_CLASSES.contains(annotationClass);
    }

    public static boolean isValidParamAnnotationClass(Class<?> annotationClass) {
        return PARAM_ANNOTATION_CLASSES.contains(annotationClass) || Context.class == annotationClass;
    }

    public static boolean isValidParamAnnotations(Annotation[] paramAnnotations) {
        for (Annotation a : paramAnnotations) {
            if (AnnotationUtils.isValidParamAnnotationClass(a.annotationType())) {
                return true;
            }
        }
        return false;
    }

    public static boolean isMethodAnnotation(Annotation a) {
        return METHOD_ANNOTATION_CLASSES.contains(a.annotationType())
               || a.annotationType().getAnnotation(HttpMethod.class) != null;
    }

    public static String getAnnotationValue(Annotation a) {
        String value = null;
        if (a.annotationType() == PathParam.class) {
            value = ((PathParam)a).value();
        } else if (a.annotationType() == QueryParam.class) {
            value = ((QueryParam)a).value();
        } else if (a.annotationType() == MatrixParam.class) {
            value = ((MatrixParam)a).value();
        } else if (a.annotationType() == HeaderParam.class) {
            value = ((HeaderParam)a).value();
        } else if (a.annotationType() == CookieParam.class) {
            value = ((CookieParam)a).value();
        } else if (a.annotationType() == FormParam.class) {
            value = ((FormParam)a).value();
        }
        return value;
    }

    public static <T> T getAnnotation(Annotation[] anns, Class<T> type) {
        if (anns == null) {
            return null;
        }
        for (Annotation a : anns) {
            if (a.annotationType() == type) {
                return type.cast(a);
            }
        }
        return null;
    }

    public static Method getAnnotatedMethod(Class<?> serviceClass, Method m) {
        Method annotatedMethod = doGetAnnotatedMethod(serviceClass, m);
        return annotatedMethod == null ? m : annotatedMethod;
    }

    private static Method doGetAnnotatedMethod(Class<?> serviceClass, Method m) {

        if (m != null) {
            if (!m.isBridge() && !m.isSynthetic()) {
                //the bridge/synthetic methods may not have the parameter annotations
                //thus we will need to search the super classes/interfaces to make 
                //sure we get the proper method that would also have the parameters annotated
                //properly
                for (Annotation a : m.getAnnotations()) {
                    if (AnnotationUtils.isMethodAnnotation(a)) {
                        return m;
                    }
                }
                for (Annotation[] paramAnnotations : m.getParameterAnnotations()) {
                    if (isValidParamAnnotations(paramAnnotations)) {
                        LOG.warning("Method " + m.getName() + " in " + m.getDeclaringClass().getName()
                                     + " has no JAX-RS Path or HTTP Method annotations");
                        return m;
                    }
                }
            }
            Class<?> declaringClass = m.getDeclaringClass();
            Class<?> superC = declaringClass.getSuperclass();
            if (superC != null && Object.class != superC) {
                try {
                    Method method = doGetAnnotatedMethod(serviceClass,
                                                         superC.getMethod(m.getName(), m.getParameterTypes()));
                    if (method != null) {
                        return method;
                    }
                } catch (NoSuchMethodException ex) {
                    // ignore
                }
            }
            for (Class<?> i : declaringClass.getInterfaces()) {
                try {
                    Method method = doGetAnnotatedMethod(serviceClass,
                                                         i.getMethod(m.getName(), m.getParameterTypes()));
                    if (method != null) {
                        return method;
                    }
                } catch (NoSuchMethodException ex) {
                    // ignore
                }
            }
            if (declaringClass != serviceClass && !declaringClass.isInterface()) {
                for (Class<?> i : serviceClass.getInterfaces()) {
                    try {
                        Method method = doGetAnnotatedMethod(serviceClass,
                                                             i.getMethod(m.getName(), m.getParameterTypes()));
                        if (method != null) {
                            return method;
                        }
                    } catch (NoSuchMethodException ex) {
                        // ignore
                    }
                }
            }
        }
        return null;
    }

    public static String getHttpMethodValue(Method m) {
        for (Annotation a : m.getAnnotations()) {
            HttpMethod httpM = a.annotationType().getAnnotation(HttpMethod.class);
            if (httpM != null) {
                return httpM.value();
            }
        }
        return null;
    }

    public static <A extends Annotation> A getMethodAnnotation(Method m, Class<A> aClass) {
        return m == null ? null : m.getAnnotation(aClass);
    }

    public static <A extends Annotation> A getClassAnnotation(Class<?> c, Class<A> aClass) {
        if (c == null) {
            return null;
        }
        A p = c.getAnnotation(aClass);
        if (p != null) {
            return p;
        }

        p = getClassAnnotation(c.getSuperclass(), aClass);
        if (p != null) {
            return p;
        }

        // finally try the first one on the interface
        for (Class<?> i : c.getInterfaces()) {
            p = getClassAnnotation(i, aClass);
            if (p != null) {
                return p;
            }
        }
        return null;
    }

    public static String getDefaultParameterValue(Annotation[] anns) {

        DefaultValue dv = AnnotationUtils.getAnnotation(anns, DefaultValue.class);
        return dv != null ? dv.value() : null;
    }

}