/*
    * Copyright 2017 The Netty Project
    *
    * The Netty Project 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 io.netty.util.internal;
  
  import java.lang.reflect.AccessibleObject;
  import java.lang.reflect.Array;
  import java.lang.reflect.GenericArrayType;
  import java.lang.reflect.ParameterizedType;
  import java.lang.reflect.Type;
  import java.lang.reflect.TypeVariable;
  
  public final class ReflectionUtil {
  
      private ReflectionUtil() { }
  
      /**
       * Try to call {@link AccessibleObject#setAccessible(boolean)} but will catch any {@link SecurityException} and
       * {@link java.lang.reflect.InaccessibleObjectException} and return it.
       * The caller must check if it returns {@code null} and if not handle the returned exception.
       */
      public static Throwable trySetAccessible(AccessibleObject object, boolean checkAccessible) {
          if (checkAccessible && !PlatformDependent0.isExplicitTryReflectionSetAccessible()) {
              return new UnsupportedOperationException("Reflective setAccessible(true) disabled");
          }
          try {
              object.setAccessible(true);
              return null;
          } catch (SecurityException e) {
              return e;
          } catch (RuntimeException e) {
              return handleInaccessibleObjectException(e);
          }
      }
  
      private static RuntimeException handleInaccessibleObjectException(RuntimeException e) {
          // JDK 9 can throw an inaccessible object exception here; since Netty compiles
          // against JDK 7 and this exception was only added in JDK 9, we have to weakly
          // check the type
          if ("java.lang.reflect.InaccessibleObjectException".equals(e.getClass().getName())) {
              return e;
          }
          throw e;
      }
  
      private static Class<?> fail(Class<?> type, String typeParamName) {
          throw new IllegalStateException(
                  "cannot determine the type of the type parameter '" + typeParamName + "': " + type);
      }
  
      /**
       * Resolve a type parameter of a class that is a subclass of the given parametrized superclass.
       * @param object The object to resolve the type parameter for
       * @param parametrizedSuperclass The parametrized superclass
       * @param typeParamName The name of the type parameter to resolve
       * @return The resolved type parameter
       * @throws IllegalStateException if the type parameter could not be resolved
       * */
      public static Class<?> resolveTypeParameter(final Object object,
                                                  Class<?> parametrizedSuperclass,
                                                  String typeParamName) {
          final Class<?> thisClass = object.getClass();
          Class<?> currentClass = thisClass;
          for (;;) {
              if (currentClass.getSuperclass() == parametrizedSuperclass) {
                  int typeParamIndex = -1;
                  TypeVariable<?>[] typeParams = currentClass.getSuperclass().getTypeParameters();
                  for (int i = 0; i < typeParams.length; i ++) {
                      if (typeParamName.equals(typeParams[i].getName())) {
                          typeParamIndex = i;
                          break;
                      }
                  }
  
                  if (typeParamIndex < 0) {
                      throw new IllegalStateException(
                              "unknown type parameter '" + typeParamName + "': " + parametrizedSuperclass);
                  }
  
                  Type genericSuperType = currentClass.getGenericSuperclass();
                  if (!(genericSuperType instanceof ParameterizedType)) {
                      return Object.class;
                  }
  
                  Type[] actualTypeParams = ((ParameterizedType) genericSuperType).getActualTypeArguments();
  
                  Type actualTypeParam = actualTypeParams[typeParamIndex];
                 if (actualTypeParam instanceof ParameterizedType) {
                     actualTypeParam = ((ParameterizedType) actualTypeParam).getRawType();
                 }
                 if (actualTypeParam instanceof Class) {
                     return (Class<?>) actualTypeParam;
                 }
                 if (actualTypeParam instanceof GenericArrayType) {
                     Type componentType = ((GenericArrayType) actualTypeParam).getGenericComponentType();
                     if (componentType instanceof ParameterizedType) {
                         componentType = ((ParameterizedType) componentType).getRawType();
                     }
                     if (componentType instanceof Class) {
                         return Array.newInstance((Class<?>) componentType, 0).getClass();
                     }
                 }
                 if (actualTypeParam instanceof TypeVariable) {
                     // Resolved type parameter points to another type parameter.
                     TypeVariable<?> v = (TypeVariable<?>) actualTypeParam;
                     if (!(v.getGenericDeclaration() instanceof Class)) {
                         return Object.class;
                     }
 
                     currentClass = thisClass;
                     parametrizedSuperclass = (Class<?>) v.getGenericDeclaration();
                     typeParamName = v.getName();
                     if (parametrizedSuperclass.isAssignableFrom(thisClass)) {
                         continue;
                     }
                     return Object.class;
                 }
 
                 return fail(thisClass, typeParamName);
             }
             currentClass = currentClass.getSuperclass();
             if (currentClass == null) {
                 return fail(thisClass, typeParamName);
             }
         }
     }
 }