/*

   * Copyright 2002-2007 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.beans;

 import java.beans.PropertyDescriptor;

 import java.lang.reflect.Constructor;

 import java.lang.reflect.InvocationTargetException;

 import java.lang.reflect.Method;

 import java.lang.reflect.Modifier;

 import java.util.Arrays;

 import java.util.List;

 import org.springframework.util.Assert;

 import org.springframework.util.ClassUtils;

 import org.springframework.util.ReflectionUtils;

 import org.springframework.util.StringUtils;

 public abstract class BeanUtils {

	

 	public static Object instantiateClass(Class clazz) throws BeanInstantiationException {

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

 		if (clazz.isInterface()) {

 			throw new BeanInstantiationException(clazz, "Specified class is an interface");

 		}

 		try {

 			return instantiateClass(clazz.getDeclaredConstructor((Class[]) null), null);

 		}

 		catch (NoSuchMethodException ex) {

 			throw new BeanInstantiationException(clazz, "No default constructor found", ex);

 		}

 	}

	

 	public static Object instantiateClass(Constructor ctor, Object[] args) throws BeanInstantiationException {

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

 		try {

 			ReflectionUtils.makeAccessible(ctor);

 			return ctor.newInstance(args);

 		}

 		catch (InstantiationException ex) {

 			throw new BeanInstantiationException(ctor.getDeclaringClass(),

 					"Is it an abstract class?", ex);

 		}

 		catch (IllegalAccessException ex) {

 			throw new BeanInstantiationException(ctor.getDeclaringClass(),

 					"Has the class definition changed? Is the constructor accessible?", ex);

 		}

 		catch (IllegalArgumentException ex) {

 			throw new BeanInstantiationException(ctor.getDeclaringClass(),

 					"Illegal arguments for constructor", ex);

 		}

 		catch (InvocationTargetException ex) {

 			throw new BeanInstantiationException(ctor.getDeclaringClass(),

 					"Constructor threw exception", ex.getTargetException());

		}

	}

	

	public static Method findMethod(Class clazz, String methodName, Class[] paramTypes) {

		try {

			return clazz.getMethod(methodName, paramTypes);

		}

		catch (NoSuchMethodException ex) {

			return findDeclaredMethod(clazz, methodName, paramTypes);

		}

	}

	

	public static Method findDeclaredMethod(Class clazz, String methodName, Class[] paramTypes) {

		try {

			return clazz.getDeclaredMethod(methodName, paramTypes);

		}

		catch (NoSuchMethodException ex) {

			if (clazz.getSuperclass() != null) {

				return findDeclaredMethod(clazz.getSuperclass(), methodName, paramTypes);

			}

			return null;

		}

	}

	

	public static Method findMethodWithMinimalParameters(Class clazz, String methodName)

			throws IllegalArgumentException {

		Method targetMethod = doFindMethodWithMinimalParameters(clazz.getDeclaredMethods(), methodName);

		if (targetMethod == null) {

			return findDeclaredMethodWithMinimalParameters(clazz, methodName);

		}

		return targetMethod;

	}

	

	public static Method findDeclaredMethodWithMinimalParameters(Class clazz, String methodName)

			throws IllegalArgumentException {

		Method targetMethod = doFindMethodWithMinimalParameters(clazz.getDeclaredMethods(), methodName);

		if (targetMethod == null && clazz.getSuperclass() != null) {

			return findDeclaredMethodWithMinimalParameters(clazz.getSuperclass(), methodName);

		}

		return targetMethod;

	}

	

	private static Method doFindMethodWithMinimalParameters(Method[] methods, String methodName)

			throws IllegalArgumentException {

		Method targetMethod = null;

		int numMethodsFoundWithCurrentMinimumArgs = 0;

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

			if (methods[i].getName().equals(methodName)) {

				int numParams = methods[i].getParameterTypes().length;

				if (targetMethod == null ||

						numParams < targetMethod.getParameterTypes().length) {

					targetMethod = methods[i];

					numMethodsFoundWithCurrentMinimumArgs = 1;

				}

				else {

					if (targetMethod.getParameterTypes().length == numParams) {

						// Additional candidate with same length.

						numMethodsFoundWithCurrentMinimumArgs++;

					}

				}

			}

		}

		if (numMethodsFoundWithCurrentMinimumArgs > 1) {

			throw new IllegalArgumentException("Cannot resolve method '" + methodName +

					"' to a unique method. Attempted to resolve to overloaded method with " +

					"the least number of parameters, but there were " +

					numMethodsFoundWithCurrentMinimumArgs + " candidates.");

		}

		return targetMethod;

	}

	

	public static Method resolveSignature(String signature, Class clazz) {

		Assert.hasText(signature, "'signature' must not be empty");

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

		int firstParen = signature.indexOf("(");

		int lastParen = signature.indexOf(")");

		if (firstParen > -1 && lastParen == -1) {

			throw new IllegalArgumentException("Invalid method signature '" + signature +

					"': expected closing ')' for args list");

		}

		else if (lastParen > -1 && firstParen == -1) {

			throw new IllegalArgumentException("Invalid method signature '" + signature +

					"': expected opening '(' for args list");

		}

		else if (firstParen == -1 && lastParen == -1) {

			return findMethodWithMinimalParameters(clazz, signature);

		}

		else {

			String methodName = signature.substring(0, firstParen);

			String[] parameterTypeNames =

					StringUtils.commaDelimitedListToStringArray(signature.substring(firstParen + 1, lastParen));

			Class[] parameterTypes = new Class[parameterTypeNames.length];

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

				String parameterTypeName = parameterTypeNames[i].trim();

				try {

					parameterTypes[i] = ClassUtils.forName(parameterTypeName, clazz.getClassLoader());

				}

				catch (Throwable ex) {

					throw new IllegalArgumentException("Invalid method signature: unable to resolve type [" +

							parameterTypeName + "] for argument " + i + ". Root cause: " + ex);

				}

			}

			return findMethod(clazz, methodName, parameterTypes);

		}

	}


	

	public static PropertyDescriptor[] getPropertyDescriptors(Class clazz) throws BeansException {

		CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);

		return cr.getBeanInfo().getPropertyDescriptors();

	}

	

	public static PropertyDescriptor getPropertyDescriptor(Class clazz, String propertyName)

			throws BeansException {

		CachedIntrospectionResults cr = CachedIntrospectionResults.forClass(clazz);

		return cr.getPropertyDescriptor(propertyName);

	}

	

	public static PropertyDescriptor findPropertyForMethod(Method method) throws BeansException {

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

		PropertyDescriptor[] pds = getPropertyDescriptors(method.getDeclaringClass());

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

			PropertyDescriptor pd = pds[i];

			if (method.equals(pd.getReadMethod()) || method.equals(pd.getWriteMethod())) {

				return pd;

			}

		}

		return null;

	}

	

	public static Class findPropertyType(String propertyName, Class[] beanClasses) {

		if (beanClasses != null) {

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

				PropertyDescriptor pd = getPropertyDescriptor(beanClasses[i], propertyName);

				if (pd != null) {

					return pd.getPropertyType();

				}

			}

		}

		return Object.class;

	}

	

	public static boolean isSimpleProperty(Class clazz) {

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

		return clazz.isPrimitive() || ClassUtils.isPrimitiveArray(clazz) ||

				ClassUtils.isPrimitiveWrapper(clazz) || ClassUtils.isPrimitiveWrapperArray(clazz) ||

				clazz.equals(String.class) || clazz.equals(String[].class) ||

				clazz.equals(Class.class) || clazz.equals(Class[].class);

	}

	

	public static boolean isAssignable(Class targetType, Class valueType) {

		return ClassUtils.isAssignable(targetType, valueType);

	}

	

	public static boolean isAssignable(Class type, Object value) {

		return ClassUtils.isAssignableValue(type, value);

	}


	

	public static void copyProperties(Object source, Object target) throws BeansException {

		copyProperties(source, target, null, null);

	}

	

	public static void copyProperties(Object source, Object target, Class editable)

			throws BeansException {

		copyProperties(source, target, editable, null);

	}

	

	public static void copyProperties(Object source, Object target, String[] ignoreProperties)

			throws BeansException {

		copyProperties(source, target, null, ignoreProperties);

	}

	

	private static void copyProperties(Object source, Object target, Class editable, String[] ignoreProperties)

			throws BeansException {

		Assert.notNull(source, "Source must not be null");

		Assert.notNull(target, "Target must not be null");

		Class actualEditable = target.getClass();

		if (editable != null) {

			if (!editable.isInstance(target)) {

				throw new IllegalArgumentException("Target class [" + target.getClass().getName() +

						"] not assignable to Editable class [" + editable.getName() + "]");

			}

			actualEditable = editable;

		}

		PropertyDescriptor[] targetPds = getPropertyDescriptors(actualEditable);

		List ignoreList = (ignoreProperties != null) ? Arrays.asList(ignoreProperties) : null;

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

			PropertyDescriptor targetPd = targetPds[i];

			if (targetPd.getWriteMethod() != null &&

					(ignoreProperties == null || (!ignoreList.contains(targetPd.getName())))) {

				PropertyDescriptor sourcePd = getPropertyDescriptor(source.getClass(), targetPd.getName());

				if (sourcePd != null && sourcePd.getReadMethod() != null) {

					try {

						Method readMethod = sourcePd.getReadMethod();

						if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers())) {

							readMethod.setAccessible(true);

						}

						Object value = readMethod.invoke(source, new Object[0]);

						Method writeMethod = targetPd.getWriteMethod();

						if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())) {

							writeMethod.setAccessible(true);

						}

						writeMethod.invoke(target, new Object[] {value});

					}

					catch (Throwable ex) {

						throw new FatalBeanException("Could not copy properties from source to target", ex);

					}

				}

			}

		}

	}

}