/*
 * Copyright (c) 2017 CEA.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *    CEA - initial API and implementation
 */
package org.eclipse.sensinact.gateway.util;

import org.json.JSONArray;
import org.json.JSONObject;
import org.osgi.framework.Bundle;

import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.GenericArrayType;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.net.URL;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Deque;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 * Reflection helpers
 */
public abstract class ReflectUtils {
    private static final Logger LOGGER = Logger.getLogger(ReflectUtils.class.getCanonicalName());

    /**
     * Returns {@link Method} contained by the {@link Collection}
     * passed as parameter whose signature is the same than the one of
     * the {@link Method} also passed as parameter. Returns null if
     * the {@link Collection} does not contain such a {@link Method}
     *
     * @param method  the {@link Method} whose signature has to be searched
     *                in the specified {@link Collection}
     * @param methods the {@link Collection} of {@link Method} in which search the
     *                signature
     * @return the {@link Method} contained by the {@link Collection} whose
     * signature is the same than the one of the specified
     * {@link Method}
     */
    public static Method containsSignature(Method method, Collection<Method> methods) {
        if (methods == null || methods.isEmpty()) {
            return null;
        }
        Iterator<Method> iterator = methods.iterator();
        while (iterator.hasNext()) {
            Method containedMethod = iterator.next();
            if (signatureEquals(method, containedMethod)) {
                return containedMethod;
            }
        }
        return null;
    }

    /**
     * Returns true is the signatures of the two {@link Method}s
     * passed as parameters are the same ; returns false
     * otherwise
     *
     * @param first  the first of the two {@link Method}s to compare
     *               the signatures of
     * @param second the second of the two {@link Method}s to compare
     *               the signatures of
     * @return true is the signatures of the two {@link Method}s
     * are the same; <br/>false otherwise
     */
    public static boolean signatureEquals(Method first, Method second) {
        if (first == null || second == null) {
            return false;
        }
        if (!first.getName().equals(second.getName())) {
            return false;
        }
        Class<?>[] firstParameterTypes = first.getParameterTypes();
        Class<?>[] secondParameterTypes = second.getParameterTypes();

        if (firstParameterTypes.length != secondParameterTypes.length) {
            return false;
        }
        int index = 0;
        for (; (index < firstParameterTypes.length) && (firstParameterTypes[index] == secondParameterTypes[index]); index++)
            ;
        return (index == firstParameterTypes.length);
    }

    /**
     * Returns as a list the hierarchy of interfaces implemented by the
     * bottomClass class argument which will be included as the bottom
     * of the hierarchy if it is an interface.
     *
     * @param bottomClass the class from which retrieve the list of implemented
     *                    interfaces
     * @return an ordered list of all interfaces the bottomClass implements
     */
    public static LinkedList<Class<?>> getOrderedImplementedInterfaces(Class<?> bottomClass) {
        LinkedList<Class<?>> list = new LinkedList<Class<?>>();

        if (bottomClass == null) {
            return list;
        }
        if (bottomClass.isInterface()) {
            list.offer(bottomClass);

        } else {
            list = getOrderedImplementedInterfaces(bottomClass.getSuperclass());
        }
        Class<?>[] interfaces = bottomClass.getInterfaces();
        if (interfaces != null) {
            int index = 0;
            for (; index < interfaces.length; index++) {
                LinkedList<Class<?>> inheritedList = getOrderedImplementedInterfaces(interfaces[index]);
                while (!inheritedList.isEmpty()) {
                    Class<?> inheritedClass = inheritedList.removeFirst();
                    if (!list.contains(inheritedClass)) {
                        list.offer(inheritedClass);
                    }
                }
            }
        }
        return list;
    }

    /**
     * Returns the hierarchy of interfaces extending the referenceInterface class
     * argument (which will be included as the top of the hierarchy)as an ordered
     * list, beginning from the specified bottomClass class argument which will be
     * included as the bottom of the hierarchy if it is  an interface.
     *
     * @param referenceInterface the interface for which to retrieve all extending interface
     *                           implemented by the bottomClass class argument
     * @param bottomClass        the class from which retrieve the list of implemented
     *                           extended referenceInterface interfaces
     * @return an ordered list of all extended referenceInterface interfaces
     * the bottomClass implements
     */
    public static <C> LinkedList<Class<C>> getOrderedImplementedInterfaces(Class<C> referenceInterface, Class<?> bottomClass) {
        LinkedList<Class<C>> list = new LinkedList<Class<C>>();

        if (referenceInterface == null || !referenceInterface.isInterface() || bottomClass == null || !referenceInterface.isAssignableFrom(bottomClass)) {
            return list;
        }
        if (bottomClass.isInterface()) {
            list.offer((Class<C>) bottomClass);

        } else {
            list = getOrderedImplementedInterfaces(referenceInterface, bottomClass.getSuperclass());
        }
        Class<?>[] interfaces = bottomClass.getInterfaces();
        if (interfaces != null) {
            int index = 0;
            for (; index < interfaces.length; index++) {
                if (referenceInterface.isAssignableFrom(interfaces[index])) {
                    LinkedList<Class<C>> inheritedList = getOrderedImplementedInterfaces(referenceInterface, interfaces[index]);
                    while (!inheritedList.isEmpty()) {
                        Class<?> inheritedClass = inheritedList.removeFirst();
                        if (!list.contains(inheritedClass)) {
                            list.offer((Class<C>) inheritedClass);
                        }
                    }
                }
            }
        }
        return list;
    }

    /**
     * Searches and returns the value of the constant whose name
     * is passed as parameter in an interface hierarchy specified
     * as an ordered list of classes. If the fromTop argument is
     * set to true the constant value is searched from the top
     * of the hierarchy to the bottom; otherwise it is searched
     * from the bottom to the top of the hierarchy
     *
     * @param list         an interface hierarchy specified as an ordered
     *                     list of classes in which to search for the constant
     *                     value
     * @param constantName the name of the constant to retrieve the value of
     * @param fromTop      <ul>
     *                     <li>true if the constant value must be searched
     *                     from the top to the bottom of the hierarchy</li>
     *                     <li>false if the constant value must be searched
     *                     from the bottom to the top of the hierarchy</li>
     *                     </ul>
     * @return the value of the constant or null if the value cannot
     * be found
     */
    public static <C, T> T getConstantValue(Deque<Class<C>> list, String constantName, boolean fromTop) {
        T constantValue = null;
        Iterator<Class<C>> iterator = fromTop ? list.descendingIterator() : list.iterator();
        while (iterator.hasNext()) {
            Class<C> resourceInterface = iterator.next();
            constantValue = ReflectUtils.<C, T>getConstantValue(resourceInterface, constantName);
            if (constantValue != null) {
                break;
            }
        }
        return constantValue;
    }

    /**
     * Searches and returns the value of the constant whose name
     * is passed as parameter in the Class also passed as parameter
     *
     * @param clazz        Class where to search for the constant value
     * @param constantName the name of the constant to retrieve the value of
     * @return the value of the constant or null if the value cannot
     * be found
     */
    @SuppressWarnings({"unchecked"})
    public static <C, T> T getConstantValue(Class<C> clazz, String constantName) {
        T constantValue = null;
        try {
            constantValue = (T) clazz.getField(constantName).get(null);
        } catch (Exception e) {
            //do nothing;
        }
        return constantValue;
    }

    /**
     * Returns the map of {@link Field}s of the {@link Class} passed
     * as parameter mapped to {@link Annotation} instances whose type is
     * the same as the annotationClass argument.
     *
     * @param annotated       the {@link Class} in which to search properly annotated
     *                        fields
     * @param annotationClass the expected {@link Annotation} type
     * @return the map of fields of the specified class mapped to
     * associated annotations
     */
    public static <A extends Annotation> Map<Field, A> getAnnotatedFields(Class<?> annotated, Class<A> annotationClass) {
        if (annotated == null || annotationClass == null) {
            return Collections.<Field, A>emptyMap();
        }
        Map<Field, A> annotatedFields = new HashMap<Field, A>();

        Field[] fields = annotated.getDeclaredFields();
        A annotation = null;

        int index = 0;
        int length = fields == null ? 0 : fields.length;
        for (; index < length; index++) {
            if ((annotation = fields[index].getAnnotation(annotationClass)) != null) {
                annotatedFields.put(fields[index], annotation);
                annotation = null;
            }
        }
        return annotatedFields;
    }

    /**
     * Returns the map of {@link Method}s of the {@link Class} passed
     * as parameter mapped to {@link Annotation} instances whose type is
     * the same as the annotationClass argument. If the method is not
     * annotated but overwrites an annotated one, it is mapped to the
     * annotation instance of its overwritten counterpart. Synthetic
     * and Bridge methods are excluded from the research.
     *
     * @param annotated       the {@link Class} in which to search properly annotated
     *                        methods
     * @param annotationClass the expected {@link Annotation} type
     * @return the map of methods of the specified class mapped to
     * associated annotations
     */
    public static <A extends Annotation> Map<Method, A> getAnnotatedMethods(Class<?> annotated, Class<A> annotationClass) {
        if (annotated == null || annotationClass == null) {
            return Collections.<Method, A>emptyMap();
        }
        Map<Method, A> annotatedMethods = new HashMap<Method, A>();
        ReflectUtils.getAnnotatedMethods(annotated, annotationClass, annotatedMethods);
        return annotatedMethods;
    }

    /**
     * Feeds the map passed as parameter with {@link Method}s of the
     * annotated {@link Class} argument mapped to annotationClass
     * {@link Annotation} instances annotating them. If a method is not
     * annotated but overwrites/implements an annotated one, it is mapped
     * to the annotation instance of its overwritten/implemented
     * super-class or interface method counterpart. Synthetic and Bridge
     * methods are excluded from the research.
     *
     * @param annotated       the {@link Class} in which to search properly annotated
     *                        methods
     * @param annotationClass the expected {@link Annotation} type
     * @param map             the map of methods of the specified class mapped to
     *                        annotations of the specified type annotating them
     */
    private static final <A extends Annotation> void getAnnotatedMethods(Class<?> annotated, Class<A> annotationClass, Map<Method, A> map) {
        if (annotated == null) {
            return;
        }
        Method[] methods = annotated.getDeclaredMethods();
        Set<Method> methodsSet = map.keySet();

        int index = 0;
        A annotation = null;
        for (; index < methods.length; index++) {
            if (methods[index].isSynthetic() || methods[index].isBridge() || containsSignature(methods[index], methodsSet) != null) {
                continue;
            }
            if ((annotation = ReflectUtils.getAnnotation(methods[index], annotationClass)) != null) {
                map.put(methods[index], annotation);
            }
        }
        getAnnotatedMethods(annotated.getSuperclass(), annotationClass, map);
    }


    /**
     * Returns the {@link Annotation} instance of the type passed as
     * parameter, annotating the {@link Method} also passed as
     * parameter or its overwritten/implemented counterpart from
     * a super-class or an interface
     *
     * @param method          the method where to search for the {@link Annotation}
     * @param annotationClass the type of the {@link Annotation} to search for
     * @return the {@link Annotation} instance annotating the {@link
     * Method} or its overwritten/implemented counterpart from
     * a super-class or an interface
     */
    public static <A extends Annotation> A getAnnotation(Method method, Class<A> annotationClass) {
        A annotation = retrieveInheritedAnnotation(method, annotationClass);

        if (annotation == null) {
            LinkedList<Class<?>> implementedInterfaces = ReflectUtils.getOrderedImplementedInterfaces(method.getDeclaringClass());

            Iterator<Class<?>> iterator = implementedInterfaces.iterator();
            while (iterator.hasNext()) {
                Method implementedMethod = ReflectUtils.containsSignature(method, Arrays.<Method>asList(iterator.next().getDeclaredMethods()));

                if (implementedMethod != null && (annotation = implementedMethod.getAnnotation(annotationClass)) != null) {
                    break;
                }
            }
        }
        return annotation;
    }

    /**
     * Returns the {@link Annotation} instance of the type passed as
     * parameter, annotating the {@link Method} also passed as
     * parameter or its overwritten counterpart from a super-class
     *
     * @param method          the method where to search for the {@link Annotation}
     * @param annotationClass the type of the {@link Annotation} to search the instance
     *                        of
     * @return the {@link Annotation} instance annotating the {@link
     * Method} or its overwritten counterpart from a super-class
     */
    private static final <A extends Annotation> A retrieveInheritedAnnotation(Method method, Class<A> annotationClass) {
        if (method == null || annotationClass == null) {
            return null;
        }
        A annotation = method.getAnnotation(annotationClass);
        if (annotation == null) {
            annotation = retrieveInheritedAnnotation(overwritten(method), annotationClass);
        }
        return annotation;
    }

    /**
     * Returns true if the {@link Method} passed as
     * parameter is valid according to the other
     * specified parameter :
     * <ul>
     * <li>the same returned type or void if the
     * acceptVoid argument is set to true</li>
     * <li>the same name if the strict argument
     * is set to true</li>
     * <li>the same parameter types</li>
     * <lu>
     *
     * @param method         the method to validate
     * @param returnedType   the returned type
     * @param methodName     the method name
     * @param parameterTypes the parameter classes array
     * @param acceptVoid     defines if the returned type as to
     *                       be the same as the specified one or if
     *                       a Void returned type is allowed
     * @param strict         defines if the method's name as to be
     *                       the same as the specified one
     * @return true if the method is valid; returns
     * false otherwise
     */
    public static boolean validMethod(Method method, Class<?> returnedType, String methodName, Class<?>[] parameterTypes, boolean acceptVoid, boolean strict) {
        if (method == null) {
            return false;
        }
        Class<?>[] methodParameterTypes = method.getParameterTypes();
        int parametersLength = parameterTypes == null ? 0 : parameterTypes.length;

        if ((parametersLength != methodParameterTypes.length) || (strict && (methodName == null || !methodName.equals(method.getName()))) || ((returnedType == null || !returnedType.isAssignableFrom(method.getReturnType())) && (!acceptVoid || !method.getReturnType().equals(Void.TYPE)))) {
            return false;
        }
        int parameterIndex = 0;
        for (; parameterIndex < parametersLength && (methodParameterTypes[parameterIndex].isAssignableFrom(parameterTypes[parameterIndex])); parameterIndex++)
            ;

        if (parameterIndex != parametersLength) {
            return false;
        }
        return true;
    }

    /**
     * Returns the first {@link Method} validating the
     * specified parameters in the array of the ones
     * passed as parameter
     *
     * @param methods        the array of {@link Method}
     * @param returnedType   the returned type
     * @param parameterTypes the parameter classes array
     * @param acceptVoid     defines if the returned type as to
     *                       be the same as the specified one or if
     *                       a Void returned type is allowed
     * @return the first method validing the parameters
     */
    public static Method getDeclaredMethod(Method[] methods, Class<?> returnedType, Class<?>[] parameterTypes, boolean acceptVoid) {
        int index = 0;
        int length = methods == null ? 0 : methods.length;

        Method method = null;

        for (; index < length; index++) {
            if (validMethod(methods[index], returnedType, null, parameterTypes, acceptVoid, false)) {
                method = methods[index];
                break;
            }
        }
        return method;
    }

    /**
     * Returns the first {@link Method} validating the
     * specified parameters in the array of the ones
     * passed as parameter
     *
     * @param methods        the array of {@link Method}
     * @param returnedType   the returned type
     * @param methodName     the method's name
     * @param parameterTypes the parameter classes array
     * @param acceptVoid     defines if the returned type as to
     *                       be the same as the specified one or if
     *                       a Void returned type is allowed
     * @return the first method validing the parameters
     */
    public static Method getDeclaredMethod(Method[] methods, Class<?> returnedType, String methodName, Class<?>[] parameterTypes, boolean acceptVoid) {
        int index = 0;
        int length = methods == null ? 0 : methods.length;

        Method method = null;

        for (; index < length; index++) {
            if (validMethod(methods[index], returnedType, methodName, parameterTypes, acceptVoid, methodName != null)) {
                method = methods[index];
                break;
            }
        }
        return method;
    }

    /**
     * Returns the first {@link Method} validating the
     * specified parameters in the set of the ones declared
     * for the type passed as parameter
     *
     * @param declaringClass the type in which to search the
     *                       valid {@link Method}
     * @param returnedType   the returned type
     * @param methodName     the method's name
     * @param parameterTypes the parameter classes array
     * @param acceptVoid     defines if the returned type as to
     *                       be the same as the specified one or if
     *                       a Void returned type is allowed
     * @return the first method validing the parameters
     */
    public static Method getDeclaredMethod(Class<?> declaringClass, Class<?> returnedType, String methodName, Class<?>[] parameterTypes, boolean acceptVoid) {
        if (declaringClass == null || methodName == null || (returnedType == null && acceptVoid == false)) {
            return null;
        }
        if (returnedType == null) {
            returnedType = Void.class;
        }
        Method method = getDeclaredMethod(declaringClass.getMethods(), returnedType, methodName, parameterTypes, acceptVoid);

        if (method == null) {
            method = getDeclaredMethod(declaringClass.getDeclaredMethods(), returnedType, methodName, parameterTypes, acceptVoid);
        }
        return method;
    }


    /**
     * Returns the {@link Method} instance the one passed
     * as parameter overwrites if it exists; otherwise
     * returns null
     *
     * @param method the method or which to retrieve the overwritten
     *               one
     * @return the overwritten method or null if the specified
     * method does not overwrite a super class one
     */
    public static Method overwritten(Method method) {
        Method overwritten = null;
        if (method != null) {
            String methodName = method.getName();
            Class<?>[] parameterTypes = method.getParameterTypes();
            Class<?> declaringClass = method.getDeclaringClass();

            while (overwritten == null && declaringClass != null) {
                try {
                    declaringClass = declaringClass.getSuperclass();
                    overwritten = declaringClass.getDeclaredMethod(methodName, parameterTypes);

                } catch (Exception e) {
                    continue;
                }
            }
        }
        return overwritten;
    }

    /**
     * Returns a new instance of the implementation class passed
     * as parameter using the parameters array as argument
     *
     * @param baseClass           the class which the implementation one
     *                            as to extend
     * @param implementationClass the class to instantiate
     * @param parameters          the objects array parameters to use
     * @return a new instance of the implementation class
     */
    public static <E, F> F getInstance(Class<E> baseClass, Class<F> implementationClass, Object... parameters) {
        if (baseClass == implementationClass) {
            return ReflectUtils.<F>getInstance(implementationClass, parameters);
        }
        F instance = null;

        try {
            if (implementationClass != null && baseClass != null && baseClass.isAssignableFrom(implementationClass)) {
                if (parameters == null || parameters.length == 0) {
                    instance = implementationClass.newInstance();

                } else {
                    @SuppressWarnings("unchecked") Constructor<F>[] constructors = (Constructor<F>[]) implementationClass.getDeclaredConstructors();

                    for (Constructor<F> constructor : constructors) {
                        Class<?>[] parameterTypes = null;

                        if ((parameterTypes = constructor.getParameterTypes()).length == parameters.length) {
                            int index = 0;

                            for (; index < parameterTypes.length && (parameters[index] == null || parameterTypes[index].isAssignableFrom(parameters[index].getClass())); index++)
                                ;

                            if (index == parameterTypes.length) {
                                constructor.setAccessible(true);
                                instance = constructor.newInstance(parameters);
                                break;
                            }
                        }
                    }
                }
            } else {
                LOGGER.log(Level.CONFIG, baseClass.getName() + " is not assignable from " + implementationClass.getName());
            }
        } catch (Exception e) {
            LOGGER.log(Level.CONFIG, e.getMessage(), e);
        }
        return instance;
    }

    /**
     * Returns a new instance of the implementation class passed
     * as parameter using the parameters array as argument
     *
     * @param implementationClass the class to instantiate
     * @return a new instance of the implementation class
     */
    public static <F> F getInstance(Class<F> implementationClass, Object[] parameters) {
        F instance = null;
        try {
            @SuppressWarnings("unchecked") Constructor<F>[] constructors = (Constructor<F>[]) implementationClass.getDeclaredConstructors();

            for (Constructor<F> constructor : constructors) {
                Class<?>[] parameterTypes = null;

                if ((parameterTypes = constructor.getParameterTypes()).length == parameters.length) {
                    int index = 0;

                    for (; index < parameterTypes.length && (parameters[index] == null || parameterTypes[index].isAssignableFrom(parameters[index].getClass())); index++)
                        ;

                    if (index == parameterTypes.length) {
                        constructor.setAccessible(true);
                        instance = constructor.newInstance(parameters);
                        break;
                    }
                }
            }
            if (instance == null) {
                instance = implementationClass.newInstance();
            }
        } catch (Exception e) {
            LOGGER.log(Level.CONFIG, e.getMessage(), e);
        }
        return instance;
    }

    /**
     * Returns a new instance of the implementation class passed
     * as parameter using the parameters array as argument
     *
     * @param implementationClass the class to instantiate
     * @return a new instance of the implementation class
     */
    public static <F> F getTheBestInstance(Class<F> clazz, Object[] parameters) {
        F instance = null;
        Constructor[] constructors = clazz.getConstructors();
        int index = constructors.length - 1;

        //order constructors by decreasing arguments number
        //to use the maximum number of passed parameters
        for (; index >= 0; index--) {
            int pos = index;
            Constructor current = constructors[index];
            while (pos > 0) {
                Constructor previous = constructors[pos - 1];
                if (previous.getParameterTypes().length < current.getParameterTypes().length) {
                    constructors[pos] = previous;
                    constructors[pos - 1] = current;
                    pos--;
                    continue;
                }
                break;
            }
        }
        index = 0;
        int position = 0;
        for (; index < constructors.length; index++) {
            Class<?>[] parameterTypes = constructors[index].getParameterTypes();
            if (parameterTypes.length > parameters.length) {
                continue;
            }
            Object[] params = new Object[parameterTypes.length];

            int paramsIndex = 0;
            int parametersIndex = 0;
            int parametersLength = parameters == null ? 0 : parameters.length;

            for (; parametersIndex < parametersLength && paramsIndex < params.length; parametersIndex++) {
                Object parameter = parameters[parametersIndex];
                if (parameter != null && parameterTypes[paramsIndex].isAssignableFrom(parameter.getClass())) {
                    params[paramsIndex++] = parameter;
                }
            }
            if (paramsIndex == parameterTypes.length) {
                try {
                    instance = (F) constructors[index].newInstance(params);
                    break;
                } catch (Exception e) {
                    continue;
                }
            }
        }
        return instance;
    }

    /**
     * Instantiate the Java object described
     * by the JSON array passed as parameter
     *
     * @param clazz      the Java type to instantiate
     * @param jsonObject the JSON array describing the java object
     *                   to instantiate
     * @return the Java object
     */
    public static <E extends Object, T> T instantiate(ClassLoader classloader, Class<T> clazz, JSONArray jsonObject) {
        T instance = null;

        if (jsonObject == null) {
            return instance;
        }
        Constructor<T> constructor = null;
        try {
            constructor = clazz.getConstructor(JSONArray.class);
            instance = constructor.newInstance(jsonObject);

        } catch (Exception e) {
            try {
                constructor = clazz.getConstructor(new Class[]{ClassLoader.class, JSONArray.class});
                instance = constructor.newInstance(new Object[]{classloader, jsonObject});

            } catch (Exception ex) {
                LOGGER.log(Level.CONFIG, e.getMessage(), e);
            }
        }
        if (instance != null) {
            return instance;
        }
        Object[][] parameters = null;
        int length = jsonObject.length();
        parameters = new Object[length][2];
        for (int i = 0; i < length; i++) {
            parameters[i][0] = null;
            parameters[i][1] = jsonObject.get(i);
        }
        return newInstance(classloader, clazz, parameters);
    }

    /**
     * Instantiate the Java object described by the JSON object
     * (JSONObject or JSONArray ) passed as parameter
     *
     * @param clazz      the Java type to instantiate
     * @param jsonObject the JSON object describing the java one to instantiate
     * @return the Java object
     */
    public static <E extends Object, T> T instantiate(ClassLoader classloader, Class<T> clazz, JSONObject jsonObject) {
        T instance = null;
        if (jsonObject == null) {
            return instance;
        }
        Constructor<T> constructor = null;
        try {
            constructor = clazz.getConstructor(JSONObject.class);
            instance = constructor.newInstance(jsonObject);
        } catch (Exception e) {
            try {
                constructor = clazz.getConstructor(new Class[]{ClassLoader.class, JSONObject.class});
                instance = constructor.newInstance(new Object[]{classloader, jsonObject});

            } catch (Exception ex) {
                LOGGER.log(Level.CONFIG, e.getMessage(), e);
            }
        }
        if (instance != null) {
            return instance;
        }
        Object[][] parameters = null;
        String[] names = JSONObject.getNames(jsonObject);
        int length = names.length;
        parameters = new Object[length][2];
        for (int i = 0; i < length; i++) {
            parameters[i][0] = names[i];
            parameters[i][1] = (jsonObject).get(names[i]);
        }
        return newInstance(classloader, clazz, parameters);
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    private static final <E extends Object, T> T newInstance(ClassLoader classloader, Class<T> clazz, Object[][] parameters) {
        T instance = null;

        //orders public constructors according to their
        //number of parameters
        Constructor[] constructors = clazz.getConstructors();
        int index = constructors.length - 1;
        for (; index >= 0; index--) {
            int pos = index;
            Constructor current = constructors[index];

            while (pos > 0) {
                Constructor previous = constructors[pos - 1];
                if (previous.getParameterTypes().length < current.getParameterTypes().length) {
                    constructors[pos] = previous;
                    constructors[pos - 1] = current;
                    pos--;
                    continue;
                }
                break;
            }
        }
        index = constructors.length - 1;
        int position = 0;
        for (; index >= 0; index--) {
            if (constructors[index].getParameterTypes().length > parameters.length) {
                continue;
            }
            Class<?>[] parameterTypes = constructors[index].getParameterTypes();
            Object[] params = new Object[parameterTypes.length];
            int typeIndex = 0;
            for (; typeIndex < parameterTypes.length; typeIndex++) {
                Object parameter = CastUtils.getObjectFromJSON(classloader, parameterTypes[typeIndex], parameters[typeIndex][1]);

                if (parameter == null && !JSONObject.NULL.equals(parameters[typeIndex][1])) {
                    params = null;
                    break;
                }
                params[typeIndex] = parameter;
            }
            if (params != null) {
                try {
                    instance = (T) constructors[index].newInstance(params);
                    position = (typeIndex + 1);
                    break;

                } catch (Exception e) {
                    continue;
                }
            }
        }
        if (instance != null && position < parameters.length && parameters[position][0] != null) {
            for (; position < parameters.length; position++) {
                try {
                    Field field = clazz.getDeclaredField((String) parameters[position][0]);
                    Object value = parameters[position][1];

                    if (value == null || (field.getModifiers() & Modifier.FINAL) == Modifier.FINAL || (field.getModifiers() & Modifier.STATIC) == Modifier.STATIC) {
                        continue;
                    }
                    field.setAccessible(true);
                    if (List.class.isAssignableFrom(field.getType())) {
                        field.set(instance, CastUtils.toList(classloader, (Class<List<E>>) field.getType(), (Class<E>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0], (JSONArray) value));

                    } else if (Map.class.isAssignableFrom(field.getType())) {
                        field.set(instance, CastUtils.toMap(classloader, (Class<Map<String, E>>) field.getType(), (Class<E>) ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[1], (JSONObject) value));
                    } else {
                        field.set(instance, CastUtils.getObjectFromJSON(classloader, field.getType(), value));
                    }
                } catch (Exception exception) {
                    LOGGER.log(Level.CONFIG, exception.getMessage(), exception);
                    continue;
                }
            }
        }
        return instance;
    }

    /**
     * Returns the array of types from the {@link Bundle} passed as
     * parameter for which the one also passed as parameter is
     * assignable to
     *
     * @param type   the type to find the ones that it is assignable to
     * @param bundle the {@link Bundle} to search for the types in
     * @return the array of types from the specified {@link Bundle}
     * assignable to specified one
     */
    public static List<Class<?>> getAssignableTypes(Class<?> type, Bundle bundle) {
        return ReflectUtils.getAssignableTypes(type, ReflectUtils.getAllTypes(bundle));
    }

    /**
     * Returns the array of types from the List of Class passed as
     * parameter for which the type also passed as parameter is
     * assignable to
     *
     * @param type    the type to find the ones that it is assignable to
     * @param classes the List of Class to search in
     * @return the array of types from the specified List of Class
     * assignable to specified one
     */
    public static List<Class<?>> getAssignableTypes(Class<?> type, List<Class<?>> classes) {
        List<Class<?>> assignables = new ArrayList<Class<?>>();
        Iterator<Class<?>> iterator = classes.iterator();
        while (iterator.hasNext()) {
            Class<?> clazz = iterator.next();
            if (type.isAssignableFrom(clazz)) {
                assignables.add(clazz);
            }
        }
        return assignables;
    }

    /**
     * Returns the array of existing types from the Bundle
     * passed as  parameter
     *
     * @param bundle the Bundle to search for the types in
     * @return the array of types from the specified Bundle
     */
    public static List<String> getAllStringTypes(Bundle bundle) {
        List<String> types = new ArrayList<String>();

        Enumeration<URL> entries = bundle.findEntries("/", "*.class", true);

        if (entries != null) {
            while (entries.hasMoreElements()) {
                String classname = entries.nextElement().getPath();
                int startIndex = 0;
                int endIndex = classname.length() - ".class".length();
                startIndex += classname.startsWith("/") ? 1 : 0;

                classname = classname.substring(startIndex, endIndex);
                classname = classname.replace('/', '.');
                types.add(classname);
            }
        }
        return types;
    }

    /**
     * Returns the array of existing types from the Bundle
     * passed as  parameter
     *
     * @param bundle the Bundle to search for the types in
     * @return the array of types from the specified Bundle
     */
    public static List<Class<?>> getAllTypes(Bundle bundle) {
        List<String> strTypes = ReflectUtils.getAllStringTypes(bundle);

        List<Class<?>> types = new ArrayList<Class<?>>();
        if (strTypes == null || strTypes.size() == 0) {
            return types;
        }
        Iterator<String> iterator = strTypes.iterator();
        while (iterator.hasNext()) {
            try {
                types.add(bundle.loadClass(iterator.next()));

            } catch (ClassNotFoundException ex) {
                continue;
            }
        }
        return types;
    }

    /**
     * Get the underlying class for a type, or null if the type is
     * a variable type.
     *
     * @param type the type
     * @return the underlying class
     */
    public static Class<?> getClass(Type type) {
        if (type instanceof Class) {
            return (Class<?>) type;
        } else if (type instanceof ParameterizedType) {
            return getClass(((ParameterizedType) type).getRawType());
        } else if (type instanceof GenericArrayType) {
            Type componentType = ((GenericArrayType) type).getGenericComponentType();
            Class<?> componentClass = getClass(componentType);
            if (componentClass != null) {
                return Array.newInstance(componentClass, 0).getClass();
            }
        }
        return null;
    }

    /**
     * Get the actual type arguments a child class has used to
     * extend a generic base class.
     *
     * @param baseClass  the base class
     * @param childClass the child class
     * @return a list of the raw classes for the actual type arguments.
     */
    public static <T> List<Class<?>> getTypeArguments(Class<T> baseClass, Class<? extends T> childClass) {
        Map<Type, Type> resolvedTypes = new HashMap<Type, Type>();
        Type type = childClass;
        // start walking up the inheritance hierarchy until we hit baseClass
        while (!getClass(type).equals(baseClass)) {
            if (type instanceof Class) {
                // there is no useful information for us in raw types, so just keep going.
                type = ((Class<?>) type).getGenericSuperclass();
            } else {
                ParameterizedType parameterizedType = (ParameterizedType) type;
                Class<?> rawType = (Class<?>) parameterizedType.getRawType();

                Type[] actualTypeArguments = parameterizedType.getActualTypeArguments();
                TypeVariable<?>[] typeParameters = rawType.getTypeParameters();
                for (int i = 0; i < actualTypeArguments.length; i++) {
                    resolvedTypes.put(typeParameters[i], actualTypeArguments[i]);
                }

                if (!rawType.equals(baseClass)) {
                    type = rawType.getGenericSuperclass();
                }
            }
        }

        // finally, for each actual type argument provided
        //to baseClass, determine (if possible)
        // the raw class for that type argument.
        Type[] actualTypeArguments;
        if (type instanceof Class) {
            actualTypeArguments = ((Class<?>) type).getTypeParameters();
        } else {
            actualTypeArguments = ((ParameterizedType) type).getActualTypeArguments();
        }
        List<Class<?>> typeArgumentsAsClasses = new ArrayList<Class<?>>();
        // resolve types by chasing down type variables.
        for (Type baseType : actualTypeArguments) {
            while (resolvedTypes.containsKey(baseType)) {
                baseType = resolvedTypes.get(baseType);
            }
            typeArgumentsAsClasses.add(getClass(baseType));
        }
        return typeArgumentsAsClasses;
    }

}