/*

   * Copyright 2002-2008 the original author or authors.

   *

   * 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.springframework.core;

 import java.lang.reflect.GenericArrayType;

 import java.lang.reflect.Method;

 import java.lang.reflect.ParameterizedType;

 import java.lang.reflect.Type;

 import java.lang.reflect.TypeVariable;

 import java.lang.ref.WeakReference;

 import java.lang.ref.Reference;

 import java.util.Collections;

 import java.util.HashMap;

 import java.util.Map;

 import java.util.WeakHashMap;

 import org.springframework.util.Assert;

 public abstract class GenericTypeResolver {

	

 	private static final Map typeVariableCache = Collections.synchronizedMap(new WeakHashMap());


	

 	public static Type getTargetType(MethodParameter methodParam) {

 		Assert.notNull(methodParam, "MethodParameter must not be null");

 		if (methodParam.getConstructor() != null) {

 			return methodParam.getConstructor().getGenericParameterTypes()[methodParam.getParameterIndex()];

 		}

 		else {

 			if (methodParam.getParameterIndex() >= 0) {

 				return methodParam.getMethod().getGenericParameterTypes()[methodParam.getParameterIndex()];

 			}

 			else {

 				return methodParam.getMethod().getGenericReturnType();

 			}

 		}

 	}

	

 	public static Class resolveParameterType(MethodParameter methodParam, Class clazz) {

 		Type genericType = getTargetType(methodParam);

 		Assert.notNull(clazz, "Class must not be null");

 		Map typeVariableMap = getTypeVariableMap(clazz);

 		Type rawType = getRawType(genericType, typeVariableMap);

 		Class result = (rawType instanceof Class ? (Class) rawType : methodParam.getParameterType());

 		methodParam.setParameterType(result);

 		methodParam.typeVariableMap = typeVariableMap;

 		return result;

 	}

	

 	public static Class resolveReturnType(Method method, Class clazz) {

 		Assert.notNull(method, "Method must not be null");

 		Type genericType = method.getGenericReturnType();

		Assert.notNull(clazz, "Class must not be null");

		Map typeVariableMap = getTypeVariableMap(clazz);

		Type rawType = getRawType(genericType, typeVariableMap);

		return (rawType instanceof Class ? (Class) rawType : method.getReturnType());

	}


	

	static Class resolveType(Type genericType, Map typeVariableMap) {

		Type rawType = getRawType(genericType, typeVariableMap);

		return (rawType instanceof Class ? (Class) rawType : Object.class);

	}

	

	static Type getRawType(Type genericType, Map typeVariableMap) {

		Type resolvedType = genericType;

		if (genericType instanceof TypeVariable) {

			TypeVariable tv = (TypeVariable) genericType;

			resolvedType = (Type) typeVariableMap.get(tv);

			if (resolvedType == null) {

				resolvedType = extractBoundForTypeVariable(tv);

			}

		}

		if (resolvedType instanceof ParameterizedType) {

			return ((ParameterizedType) resolvedType).getRawType();

		}

		else {

			return resolvedType;

		}

	}

	

	static Map getTypeVariableMap(Class clazz) {

		Reference ref = (Reference) typeVariableCache.get(clazz);

		Map typeVariableMap = (Map) (ref != null ? ref.get() : null);

		if (typeVariableMap == null) {

			typeVariableMap = new HashMap();

			// interfaces

			extractTypeVariablesFromGenericInterfaces(clazz.getGenericInterfaces(), typeVariableMap);

			// super class

			Type genericType = clazz.getGenericSuperclass();

			Class type = clazz.getSuperclass();

			while (type != null && !Object.class.equals(type)) {

				if (genericType instanceof ParameterizedType) {

					ParameterizedType pt = (ParameterizedType) genericType;

					populateTypeMapFromParameterizedType(pt, typeVariableMap);

				}

				extractTypeVariablesFromGenericInterfaces(type.getGenericInterfaces(), typeVariableMap);

				genericType = type.getGenericSuperclass();

				type = type.getSuperclass();

			}

			// enclosing class

			type = clazz;

			while (type.isMemberClass()) {

				genericType = type.getGenericSuperclass();

				if (genericType instanceof ParameterizedType) {

					ParameterizedType pt = (ParameterizedType) genericType;

					populateTypeMapFromParameterizedType(pt, typeVariableMap);

				}

				type = type.getEnclosingClass();

			}

			typeVariableCache.put(clazz, new WeakReference(typeVariableMap));

		}

		return typeVariableMap;

	}

	

	static Type extractBoundForTypeVariable(TypeVariable typeVariable) {

		Type[] bounds = typeVariable.getBounds();

		if (bounds.length == 0) {

			return Object.class;

		}

		Type bound = bounds[0];

		if (bound instanceof TypeVariable) {

			bound = extractBoundForTypeVariable((TypeVariable) bound);

		}

		return bound;

	}

	private static void extractTypeVariablesFromGenericInterfaces(Type[] genericInterfaces, Map typeVariableMap) {

		for (int i = 0; i < genericInterfaces.length; i++) {

			Type genericInterface = genericInterfaces[i];

			if (genericInterface instanceof ParameterizedType) {

				ParameterizedType pt = (ParameterizedType) genericInterface;

				populateTypeMapFromParameterizedType(pt, typeVariableMap);

				if (pt.getRawType() instanceof Class) {

					extractTypeVariablesFromGenericInterfaces(

							((Class) pt.getRawType()).getGenericInterfaces(), typeVariableMap);

				}

			}

			else if (genericInterface instanceof Class) {

				extractTypeVariablesFromGenericInterfaces(

						((Class) genericInterface).getGenericInterfaces(), typeVariableMap);

			}

		}

	}

	

	private static void populateTypeMapFromParameterizedType(ParameterizedType type, Map typeVariableMap) {

		if (type.getRawType() instanceof Class) {

			Type[] actualTypeArguments = type.getActualTypeArguments();

			TypeVariable[] typeVariables = ((Class) type.getRawType()).getTypeParameters();

			for (int i = 0; i < actualTypeArguments.length; i++) {

				Type actualTypeArgument = actualTypeArguments[i];

				TypeVariable variable = typeVariables[i];

				if (actualTypeArgument instanceof Class) {

					typeVariableMap.put(variable, actualTypeArgument);

				}

				else if (actualTypeArgument instanceof GenericArrayType) {

					typeVariableMap.put(variable, actualTypeArgument);

				}

				else if (actualTypeArgument instanceof ParameterizedType) {

					typeVariableMap.put(variable, actualTypeArgument);

				}

				else if (actualTypeArgument instanceof TypeVariable) {

					// We have a type that is parameterized at instantiation time

					// the nearest match on the bridge method will be the bounded type.

					TypeVariable typeVariableArgument = (TypeVariable) actualTypeArgument;

					Type resolvedType = (Type) typeVariableMap.get(typeVariableArgument);

					if (resolvedType == null) {

						resolvedType = extractBoundForTypeVariable(typeVariableArgument);

					}

					typeVariableMap.put(variable, resolvedType);

				}

			}

		}

	}

}