/*
 * 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
 *
 *      https://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.commons.lang3.reflect;

import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

import org.apache.commons.lang3.ClassUtils;

/**
 * Contains common code for working with {@link java.lang.reflect.Method Methods}/{@link java.lang.reflect.Constructor Constructors},
 * extracted and refactored from {@link MethodUtils} when it was imported from Commons BeanUtils.
 */
final class MemberUtils {
    // TODO extract an interface to implement compareParameterSets(...)?

    /**
     * A class providing a subset of the API of java.lang.reflect.Executable in Java 1.8,
     * providing a common representation for function signatures for Constructors and Methods.
     */
    private static final class Executable {

        private static Executable of(final Constructor<?> constructor) {
            return new Executable(constructor);
        }

        private static Executable of(final Method method) {
            return new Executable(method);
        }

        private final Class<?>[] parameterTypes;
        private final boolean isVarArgs;

        private Executable(final Constructor<?> constructor) {
            parameterTypes = constructor.getParameterTypes();
            isVarArgs = constructor.isVarArgs();
        }

        private Executable(final Method method) {
            parameterTypes = method.getParameterTypes();
            isVarArgs = method.isVarArgs();
        }

        public Class<?>[] getParameterTypes() {
            return parameterTypes;
        }

        public boolean isVarArgs() {
            return isVarArgs;
        }
    }

    private static final int ACCESS_TEST = Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE;

    /**
     * Array of primitive number types ordered by "promotability" from narrow to wide.
     */
    private static final Class<?>[] WIDENING_PRIMITIVE_TYPES = {
            // @formatter:off
            Byte.TYPE,      // byte
            Short.TYPE,     // short
            Character.TYPE, // char
            Integer.TYPE,   // int
            Long.TYPE,      // long
            Float.TYPE,     // float
            Double.TYPE     // double
            // @formatter:on
    };

    /**
     * Compares the relative fitness of two Constructors in terms of how well they match a set of runtime parameter types, such that a list ordered by the
     * results of the comparison would return the best match first (least).
     *
     * @param left   the "left" Constructor.
     * @param right  the "right" Constructor.
     * @param actual the runtime parameter types to match against. {@code left}/{@code right}.
     * @return int consistent with {@code compare} semantics.
     */
    static int compareConstructorFit(final Constructor<?> left, final Constructor<?> right, final Class<?>[] actual) {
      return compareParameterTypes(Executable.of(left), Executable.of(right), actual);
    }

    /**
     * Compares the relative fitness of two Methods in terms of how well they match a set of runtime parameter types, such that a list ordered by the results of
     * the comparison would return the best match first (least).
     *
     * @param left   the "left" Method.
     * @param right  the "right" Method.
     * @param actual the runtime parameter types to match against. {@code left}/{@code right}.
     * @return int consistent with {@code compare} semantics.
     */
    static int compareMethodFit(final Method left, final Method right, final Class<?>[] actual) {
      return compareParameterTypes(Executable.of(left), Executable.of(right), actual);
    }

    /**
     * Compares the relative fitness of two Executables in terms of how well they match a set of runtime parameter types, such that a list ordered by the
     * results of the comparison would return the best match first (least).
     *
     * @param left   the "left" Executable.
     * @param right  the "right" Executable.
     * @param actual the runtime parameter types to match against. {@code left}/{@code right}.
     * @return int consistent with {@code compare} semantics.
     */
    private static int compareParameterTypes(final Executable left, final Executable right, final Class<?>[] actual) {
        final float leftCost = getTotalTransformationCost(actual, left);
        final float rightCost = getTotalTransformationCost(actual, right);
        return Float.compare(leftCost, rightCost);
    }

    /**
     * Gets the number of steps needed to turn the source class into the destination class. This represents the number of steps in the object hierarchy graph.
     *
     * @param srcClass  The source class.
     * @param destClass The destination class.
     * @return The cost of transforming an object.
     */
    private static float getObjectTransformationCost(Class<?> srcClass, final Class<?> destClass) {
        if (destClass.isPrimitive()) {
            return getPrimitivePromotionCost(srcClass, destClass);
        }
        float cost = 0.0f;
        while (srcClass != null && !destClass.equals(srcClass)) {
            if (destClass.isInterface() && ClassUtils.isAssignable(srcClass, destClass)) {
                // slight penalty for interface match.
                // we still want an exact match to override an interface match,
                // but
                // an interface match should override anything where we have to
                // get a superclass.
                cost += 0.25f;
                break;
            }
            cost++;
            srcClass = srcClass.getSuperclass();
        }
        /*
         * If the destination class is null, we've traveled all the way up to an Object match. We'll penalize this by adding 1.5 to the cost.
         */
        if (srcClass == null) {
            cost += 1.5f;
        }
        return cost;
    }

    /**
     * Gets the number of steps required to promote a primitive to another type.
     *
     * @param srcClass  the (primitive) source class.
     * @param destClass the (primitive) destination class.
     * @return The cost of promoting the primitive.
     */
    private static float getPrimitivePromotionCost(final Class<?> srcClass, final Class<?> destClass) {
        if (srcClass == null) {
            return 1.5f;
        }
        float cost = 0.0f;
        Class<?> cls = srcClass;
        if (!cls.isPrimitive()) {
            // slight unwrapping penalty
            cost += 0.1f;
            cls = ClassUtils.wrapperToPrimitive(cls);
        }
        // Increase the cost as the loop widens the type.
        for (int i = 0; cls != destClass && i < WIDENING_PRIMITIVE_TYPES.length; i++) {
            if (cls == WIDENING_PRIMITIVE_TYPES[i]) {
                cost += 0.1f;
                if (i < WIDENING_PRIMITIVE_TYPES.length - 1) {
                    cls = WIDENING_PRIMITIVE_TYPES[i + 1];
                }
            }
        }
        return cost;
    }

    /**
     * Gets the sum of the object transformation cost for each class in the source argument list.
     *
     * @param srcArgs    The source arguments.
     * @param executable The executable to calculate transformation costs for.
     * @return The total transformation cost.
     */
    private static float getTotalTransformationCost(final Class<?>[] srcArgs, final Executable executable) {
        final Class<?>[] destArgs = executable.getParameterTypes();
        final boolean isVarArgs = executable.isVarArgs();
        // "source" and "destination" are the actual and declared args respectively.
        float totalCost = 0.0f;
        final long normalArgsLen = isVarArgs ? destArgs.length - 1 : destArgs.length;
        if (srcArgs.length < normalArgsLen) {
            return Float.MAX_VALUE;
        }
        for (int i = 0; i < normalArgsLen; i++) {
            totalCost += getObjectTransformationCost(srcArgs[i], destArgs[i]);
        }
        if (isVarArgs) {
            // When isVarArgs is true, srcArgs and dstArgs may differ in length.
            // There are two special cases to consider:
            final boolean noVarArgsPassed = srcArgs.length < destArgs.length;
            final boolean explicitArrayForVarargs = srcArgs.length == destArgs.length && srcArgs[srcArgs.length - 1] != null
                    && srcArgs[srcArgs.length - 1].isArray();
            final float varArgsCost = 0.001f;
            final Class<?> destClass = destArgs[destArgs.length - 1].getComponentType();
            if (noVarArgsPassed) {
                // When no varargs passed, the best match is the most generic matching type, not the most specific.
                totalCost += getObjectTransformationCost(destClass, Object.class) + varArgsCost;
            } else if (explicitArrayForVarargs) {
                final Class<?> sourceClass = srcArgs[srcArgs.length - 1].getComponentType();
                totalCost += getObjectTransformationCost(sourceClass, destClass) + varArgsCost;
            } else {
                // This is typical varargs case.
                for (int i = destArgs.length - 1; i < srcArgs.length; i++) {
                    final Class<?> srcClass = srcArgs[i];
                    totalCost += getObjectTransformationCost(srcClass, destClass) + varArgsCost;
                }
            }
        }
        return totalCost;
    }

    /**
     * Tests whether a {@link Member} is accessible.
     *
     * @param member Member to test, may be null.
     * @return {@code true} if {@code m} is accessible.
     */
    static boolean isAccessible(final Member member) {
        return isPublic(member) && !member.isSynthetic();
    }

    static boolean isMatchingConstructor(final Constructor<?> method, final Class<?>[] parameterTypes) {
        return isMatchingExecutable(Executable.of(method), parameterTypes);
    }

    private static boolean isMatchingExecutable(final Executable method, final Class<?>[] parameterTypes) {
        final Class<?>[] methodParameterTypes = method.getParameterTypes();
        if (ClassUtils.isAssignable(parameterTypes, methodParameterTypes, true)) {
            return true;
        }
        if (method.isVarArgs()) {
            int i;
            for (i = 0; i < methodParameterTypes.length - 1 && i < parameterTypes.length; i++) {
                if (!ClassUtils.isAssignable(parameterTypes[i], methodParameterTypes[i], true)) {
                    return false;
                }
            }
            final Class<?> varArgParameterType = methodParameterTypes[methodParameterTypes.length - 1].getComponentType();
            for (; i < parameterTypes.length; i++) {
                if (!ClassUtils.isAssignable(parameterTypes[i], varArgParameterType, true)) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

    static boolean isMatchingMethod(final Method method, final Class<?>[] parameterTypes) {
      return isMatchingExecutable(Executable.of(method), parameterTypes);
    }

    /**
     * Tests whether a given set of modifiers implies package access.
     *
     * @param modifiers to test.
     * @return {@code true} unless {@code package}/{@code protected}/{@code private} modifier detected
     */
    static boolean isPackage(final int modifiers) {
        return (modifiers & ACCESS_TEST) == 0;
    }

    /**
     * Tests whether a {@link Member} is public.
     *
     * @param member Member to test, may be null.
     * @return {@code true} if {@code m} is public.
     */
    static boolean isPublic(final Member member) {
        return member != null && Modifier.isPublic(member.getModifiers());
    }

    /**
     * Tests whether a {@link Member} is static.
     *
     * @param member Member to test, may be null.
     * @return {@code true} if {@code m} is static.
     */
    static boolean isStatic(final Member member) {
        return member != null && Modifier.isStatic(member.getModifiers());
    }

    /**
     * Default access superclass workaround.
     * <p>
     * When a {@code public} class has a default access superclass with {@code public} members,
     * these members are accessible. Calling them from compiled code works fine.
     * Unfortunately, on some JVMs, using reflection to invoke these members
     * seems to (wrongly) prevent access even when the modifier is {@code public}.
     * Calling {@code setAccessible(true)} solves the problem but will only work from
     * sufficiently privileged code. Better workarounds would be gratefully
     * accepted.
     * </p>
     *
     * @param obj the AccessibleObject to set as accessible, may be null.
     * @return a boolean indicating whether the accessibility of the object was set to true.
     */
    static <T extends AccessibleObject> T setAccessibleWorkaround(final T obj) {
        if (AccessibleObjects.isAccessible(obj)) {
            return obj;
        }
        final Member m = (Member) obj;
        if (isPublic(m) && isPackage(m.getDeclaringClass().getModifiers())) {
            try {
                obj.setAccessible(true);
                return obj;
            } catch (final SecurityException ignored) {
                // Ignore in favor of subsequent IllegalAccessException
            }
        }
        return obj;
    }

}
