/*

   * Copyright 2002-2009 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.annotation.Annotation;

 import java.lang.reflect.Constructor;

 import java.lang.reflect.Method;

 import java.lang.reflect.Type;

 import java.lang.reflect.TypeVariable;

 import java.util.HashMap;

 import java.util.Map;

 import org.springframework.util.Assert;

 public class MethodParameter {

 	private Method method;

 	private Constructor constructor;

 	private final int parameterIndex;

 	private Class<?> parameterType;

 	private Type genericParameterType;

 	private Annotation[] parameterAnnotations;

 	private ParameterNameDiscoverer parameterNameDiscoverer;

 	private String parameterName;

 	private int nestingLevel = 1;

	

 	private Map<Integer,Integer> typeIndexesPerLevel;

 	Map<TypeVariable, Type> typeVariableMap;


	

 	public MethodParameter(Method method, int parameterIndex) {

 		this(method, parameterIndex, 1);

 	}

	

 	public MethodParameter(Method method, int parameterIndex, int nestingLevel) {

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

 		this.method = method;

 		this.parameterIndex = parameterIndex;

 		this.nestingLevel = nestingLevel;

 	}

	

 	public MethodParameter(Constructor constructor, int parameterIndex) {

 		this(constructor, parameterIndex, 1);

 	}

	

	public MethodParameter(Constructor constructor, int parameterIndex, int nestingLevel) {

		Assert.notNull(constructor, "Constructor must not be null");

		this.constructor = constructor;

		this.parameterIndex = parameterIndex;

		this.nestingLevel = nestingLevel;

	}

	

	public MethodParameter(MethodParameter original) {

		Assert.notNull(original, "Original must not be null");

		this.method = original.method;

		this.constructor = original.constructor;

		this.parameterIndex = original.parameterIndex;

		this.parameterType = original.parameterType;

		this.parameterAnnotations = original.parameterAnnotations;

		this.typeVariableMap = original.typeVariableMap;

	}


	

	public Method getMethod() {

		return this.method;

	}

	

	public Constructor getConstructor() {

		return this.constructor;

	}

	

	public Class getDeclaringClass() {

		return (this.method != null ? this.method.getDeclaringClass() : this.constructor.getDeclaringClass());

	}

	

	public int getParameterIndex() {

		return this.parameterIndex;

	}

	

	void setParameterType(Class<?> parameterType) {

		this.parameterType = parameterType;

	}

	

	public Class<?> getParameterType() {

		if (this.parameterType == null) {

			if (this.parameterIndex < 0) {

				this.parameterType = (this.method != null ? this.method.getReturnType() : null);

			}

			else {

				this.parameterType = (this.method != null ?

					this.method.getParameterTypes()[this.parameterIndex] :

					this.constructor.getParameterTypes()[this.parameterIndex]);

			}

		}

		return this.parameterType;

	}

	

	public Type getGenericParameterType() {

		if (this.genericParameterType == null) {

			if (this.parameterIndex < 0) {

				this.genericParameterType = (this.method != null ? this.method.getGenericReturnType() : null);

			}

			else {

				this.genericParameterType = (this.method != null ?

					this.method.getGenericParameterTypes()[this.parameterIndex] :

					this.constructor.getGenericParameterTypes()[this.parameterIndex]);

			}

		}

		return this.genericParameterType;

	}

	

	public Annotation[] getMethodAnnotations() {

		return (this.method != null ? this.method.getAnnotations() : this.constructor.getAnnotations());

	}

	

	@SuppressWarnings("unchecked")

	public <T extends Annotation> T getMethodAnnotation(Class<T> annotationType) {

		return (this.method != null ? this.method.getAnnotation(annotationType) :

				(T) this.constructor.getAnnotation(annotationType));

	}

	

	public Annotation[] getParameterAnnotations() {

		if (this.parameterAnnotations == null) {

			Annotation[][] annotationArray = (this.method != null ?

					this.method.getParameterAnnotations() : this.constructor.getParameterAnnotations());

			this.parameterAnnotations = annotationArray[this.parameterIndex];

		}

		return this.parameterAnnotations;

	}

	

	@SuppressWarnings("unchecked")

	public <T extends Annotation> T getParameterAnnotation(Class<T> annotationType) {

		Annotation[] anns = getParameterAnnotations();

		for (Annotation ann : anns) {

			if (annotationType.isInstance(ann)) {

				return (T) ann;

			}

		}

		return null;

	}

	

	public void initParameterNameDiscovery(ParameterNameDiscoverer parameterNameDiscoverer) {

		this.parameterNameDiscoverer = parameterNameDiscoverer;

	}

	

	public String getParameterName() {

		if (this.parameterNameDiscoverer != null) {

			String[] parameterNames = (this.method != null ?

					this.parameterNameDiscoverer.getParameterNames(this.method) :

					this.parameterNameDiscoverer.getParameterNames(this.constructor));

			if (parameterNames != null) {

				this.parameterName = parameterNames[this.parameterIndex];

			}

			this.parameterNameDiscoverer = null;

		}

		return this.parameterName;

	}

	

	public void increaseNestingLevel() {

		this.nestingLevel++;

	}

	

	public void decreaseNestingLevel() {

		getTypeIndexesPerLevel().remove(this.nestingLevel);

		this.nestingLevel--;

	}

	

	public int getNestingLevel() {

		return this.nestingLevel;

	}

	

	public void setTypeIndexForCurrentLevel(int typeIndex) {

		getTypeIndexesPerLevel().put(this.nestingLevel, typeIndex);

	}

	

	public Integer getTypeIndexForCurrentLevel() {

		return getTypeIndexForLevel(this.nestingLevel);

	}

	

	public Integer getTypeIndexForLevel(int nestingLevel) {

		return getTypeIndexesPerLevel().get(nestingLevel);

	}

	

	private Map<Integer, Integer> getTypeIndexesPerLevel() {

		if (this.typeIndexesPerLevel == null) {

			this.typeIndexesPerLevel = new HashMap<Integer, Integer>(4);

		}

		return this.typeIndexesPerLevel;

	}


	

	public static MethodParameter forMethodOrConstructor(Object methodOrConstructor, int parameterIndex) {

		if (methodOrConstructor instanceof Method) {

			return new MethodParameter((Method) methodOrConstructor, parameterIndex);

		}

		else if (methodOrConstructor instanceof Constructor) {

			return new MethodParameter((Constructor) methodOrConstructor, parameterIndex);

		}

		else {

			throw new IllegalArgumentException(

					"Given object [" + methodOrConstructor + "] is neither a Method nor a Constructor");

		}

	}

}