/***
    * License Agreement.
    * 
    * JSPA (POJO-SP)
    * 
    * Copyright (C) 2009 HRX Pty Ltd
    * 
    * This file is part of JSPA.
    * 
   * JSPA is free software: you can redistribute it and/or modify it under the
   * terms of the GNU Lesser General Public License version 3 as published by the
   * Free Software Foundation.
   * 
   * JSPA is distributed in the hope that it will be useful, but WITHOUT ANY
   * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   * A PARTICULAR PURPOSE. See the Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public License
   * along with JSPA. If not, see <http://www.gnu.org/licenses/>.
   */
  package com.hrx.rasp.util.dao.metadata;
  
  import java.lang.annotation.Annotation;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Field;
  import java.lang.reflect.InvocationTargetException;
  import java.lang.reflect.Method;
  import java.lang.reflect.Modifier;
  import java.sql.ResultSet;
  import java.sql.SQLException;
  import java.util.Arrays;
  
  import org.apache.log4j.Logger;
  
  import com.hrx.rasp.util.dao.NullValue;
  import com.hrx.rasp.util.dao.StoredProcUtility;
  import com.hrx.rasp.util.dao.annotations.DAOConstructor;
  import com.hrx.rasp.util.dao.exception.GetterNotFoundException;
  import com.hrx.rasp.util.dao.exception.InvalidFieldException;
  import com.hrx.rasp.util.dao.exception.InvalidGetterException;
  import com.hrx.rasp.util.dao.exception.InvalidSetterException;
  import com.hrx.rasp.util.dao.exception.InvalidStoredProcedureException;
  import com.hrx.rasp.util.dao.exception.SetterNotFoundException;
  import com.hrx.rasp.util.dao.exception.StoredProcedurePrepareException;
  import com.hrx.rasp.util.dao.exception.StoredProcedureProccessResultException;
  import com.hrx.rasp.util.dao.operation.OperationType;
  
  /***
   * @author dan.stoica <dan.stoica@acslink.net.au>
   * 
   */
  public class MetadataHelper
  {
  
  	private static Logger log = Logger.getLogger(MetadataHelper.class);
  
  	protected static final String GET_METHOD = "get";
  	protected static final String SET_METHOD = "set";
  
  	/***
  	 * Invoke the method on a java Object.
  	 */
  	public static Object invokeMethod(final Method method, final Object object, final Object[] values) throws IllegalAccessException,
  					InvocationTargetException
  	{
  		// we can not invoke the method if it is not accessible
  		if (!method.isAccessible())
  		{
  			method.setAccessible(true);
  		}
  		return method.invoke(object, values);
  	}
  
  	/***
  	 * Invoke the method on a java Object with null parameters.
  	 */
  	public static Object invokeMethod(final Method method, final Object object) throws IllegalAccessException, InvocationTargetException
  	{
  		Object[] nullValues = {};
  		return invokeMethod(method, object, nullValues);
  	}
  
  	/***
  	 * Does a recursive search for the method in the classes or it's superclass.
  	 */
  	public static final Method getMethod(Class<?> pojoClass, String methodName, Class<?>[] methodParameterTypes) throws NoSuchMethodException
  	{
  		// For an extended class we have to find the most derived method
  		// version. We start searching for the named method with the given class
  		// and walk up the superclass chain
  
  		try
  		{
  			return getDeclaredMethod(pojoClass, methodName, methodParameterTypes);
  		}
  		catch (NoSuchMethodException e)
  		{
  			Class<?> superclass = pojoClass.getSuperclass();
  			if (superclass == null)
 			{
 				throw e;
 			}
 			else
 			{
 				return getMethod(superclass, methodName, methodParameterTypes);
 			}
 		}
 	}
 
 	/***
 	 * Get a method declared in the given class and suppress the Java language
 	 * access checking when it is used.
 	 */
 	private static Method getDeclaredMethod(final Class<?> pojoClass, final String methodName, final Class<?>[] methodParameterTypes)
 					throws NoSuchMethodException
 	{
 		Method method = pojoClass.getDeclaredMethod(methodName, methodParameterTypes);
 		method.setAccessible(true);
 		return method;
 	}
 
 	/***
 	 * Does a recursive search for the fields in the class or it's superclass.
 	 */
 	public final static Field[] getDeclaredFields(Class<?> pojoClass)
 	{
 		Field[] fields = pojoClass.getDeclaredFields();
 
 		// For an extended class we have to find the superclass fields too
 		// so we walk up the superclass chain
 		Class<?> superClass = pojoClass.getSuperclass();
 		if (superClass != null)
 		{
 			Field[] superFields = getDeclaredFields(superClass);
 
 			if (superFields.length > 0)
 			{
 				Field[] allFields = new Field[fields.length + superFields.length];
 				System.arraycopy(fields, 0, allFields, 0, fields.length);
 				System.arraycopy(superFields, 0, allFields, fields.length, superFields.length);
 				return allFields;
 			}
 		}
 		return fields;
 	}
 
 	/***
 	 * Does a recursive search for the fields in the Object or it's super.
 	 */
 	public final static <T> Field[] getDeclaredFields(T pojo)
 	{
 		Class<?> clazz = pojo.getClass();
 		Field[] fields = getDeclaredFields(clazz);
 		return fields;
 	}
 
 	protected static <T extends Annotation> StoredProcField<T> createStoredProcField(final Field field, final T parm)
 					throws StoredProcedurePrepareException, InvalidFieldException
 	{
 
 		StoredProcUtility.validateField(field);
 
 		String name = field.getName();
 		try
 		{
 			StoredProcField<T> spField = new StoredProcField<T>(name, field, parm);
 			if (log.isTraceEnabled())
 			{
 				log.trace("DAO: Found " + parm.annotationType().getSimpleName() + " parameter. Create field=" + name + ", param:" + spField);
 			}
 			return spField;
 		}
 		catch (Exception e)
 		{
 			throw new StoredProcedurePrepareException("Can not read the value for field:" + field.getName());
 		}
 	}
 
 	public static Object getPropertyValue(final Field field, final Object spBean) throws NoSuchMethodException, IllegalAccessException,
 					InvocationTargetException
 	{
 		String methodName = GET_METHOD + StoredProcUtility.capitalize(field.getName());
 
 		Class<?> myClass = spBean.getClass();
 		Method m = getGetMethod(myClass, methodName);
 
 		Object value = invokeMethod(m, spBean);
 
 		if (value == null)
 		{
 			value = NullValue.getFor(m.getReturnType());
 		}
 		return value;
 	}
 
 	public static Object setPropertyValue(Field field, Object value, Object spBean) throws StoredProcedureProccessResultException
 	{
 		String methodName = SET_METHOD + StoredProcUtility.capitalize(field.getName());
 
 		try
 		{
 			Class<?> myClass = spBean.getClass();
 
 			Class<?>[] params =
 			{
 				field.getType()
 			};
 			Method m = getMethod(myClass, methodName, params);
 			Object[] args =
 			{
 				value
 			};
 			invokeMethod(m, spBean, args);
 
 		}
 		catch (Exception e)
 		{
 			throw new StoredProcedureProccessResultException("Failed to call '" + methodName + "' method in dao (" + spBean + ")", e);
 		}
 
 		return value;
 	}
 
 	public static Method getGetMethod(Object spBean, String fieldName) throws NoSuchMethodException
 	{
 		String methodName = GET_METHOD + StoredProcUtility.capitalize(fieldName);
 		Class<?> myClass = spBean.getClass();
 		Method m = getGetMethod(myClass, methodName);
 		return m;
 	}
 
 	/***
 	 * @param methodName
 	 * @param myClass
 	 * @return
 	 * @throws NoSuchMethodException
 	 */
 	private static Method getGetMethod(Class<?> myClass, String methodName) throws NoSuchMethodException
 	{
 		Class<?>[] params = {};
 		Method m = getMethod(myClass, methodName, params);
 		return m;
 	}
 
 	/***
 	 * Find a target getter for a property field on a given class.
 	 * 
 	 * @param spBean
 	 * @param field
 	 * @return the getter method
 	 * @throws NoSuchMethodException
 	 */
 	public static Method getGetMethod(Object spBean, Field field) throws NoSuchMethodException
 	{
 		Method m = getGetMethod(spBean, field.getName());
 		return m;
 	}
 
 	/***
 	 * Find a target setter for a property field with a given parameter on a
 	 * given class.
 	 * 
 	 * @param spBean
 	 * @param field
 	 * @return the setter method
 	 * @throws NoSuchMethodException
 	 */
 	public static Method getSetMethod(Object spBean, Field field) throws NoSuchMethodException
 	{
 		String methodName = SET_METHOD + StoredProcUtility.capitalize(field.getName());
 		Class<?> myClass = spBean.getClass();
 		Class<?>[] params =
 		{
 			field.getType()
 		};
 		Method m = getMethod(myClass, methodName, params);
 		return m;
 	}
 
 	protected static void validateSettter(Object spBean, Field field) throws SetterNotFoundException, InvalidSetterException
 	{
 		try
 		{
 			Method m = MetadataHelper.getSetMethod(spBean, field);
 			int modifiers = m.getModifiers();
 			if (!Modifier.isPublic(modifiers))
 			{
 				throw new InvalidSetterException("Invalid Modifiers for method :" + m.getName() + ". The setters has to be public.");
 			}
 		}
 		catch (NoSuchMethodException e)
 		{
 			// we should support final fields.
 			// throw new SetterNotFoundException("Setter not found for IN
 			// parameter:" + field.getName(), e);
 		}
 	}
 
 	private static void validateGetter(Object spBean, Field field) throws GetterNotFoundException, InvalidGetterException
 	{
 		try
 		{
 			Method m = MetadataHelper.getGetMethod(spBean, field);
 			int modifiers = m.getModifiers();
 			if (!Modifier.isPublic(modifiers))
 			{
 				throw new InvalidGetterException("Invalid Modifiers for method :" + m.getName());
 			}
 		}
 		catch (NoSuchMethodException e)
 		{
 			throw new GetterNotFoundException("Getter not found for IN parameter:'" + field.getName(), e);
 		}
 	}
 
 	public static void validateGetterAndSetter(Object spBean, Field field) throws InvalidStoredProcedureException
 	{
 		MetadataHelper.validateGetter(spBean, field);
 		MetadataHelper.validateSettter(spBean, field);
 	}
 
 	/***
 	 * @param rs
 	 * @param cons
 	 * @param parameterTypes
 	 * @param args
 	 * @return
 	 * @throws SQLException
 	 * @throws InstantiationException
 	 * @throws IllegalAccessException
 	 * @throws InvocationTargetException
 	 */
 	public final static <T> T createInstance(ResultSet rs, Constructor<T> cons) throws SQLException, InstantiationException, IllegalAccessException,
 					InvocationTargetException
 	{
 		Class<?>[] parameterTypes = cons.getParameterTypes();
 		Object[] args = new Object[parameterTypes.length];
 		for (int index = 0; index < parameterTypes.length; index++)
 		{
 			Class<?> argc = parameterTypes[index];
 			args[index] = StoredProcUtility.getResultSetObject(rs, index + 1, argc);
 		}
 		T dao = cons.newInstance(args);
 		return dao;
 	}
 
 	/***
 	 * Searches the Constructor operations array for the specified operation
 	 * using the binary search algorithm. The array is sorted before the search.
 	 * 
 	 * @param operation
 	 * @param param
 	 * @return true if the named Operation or 'ALL' operation is contained in
 	 *         the array
 	 */
 	public static boolean isOperationDefined(final OperationType operation, DAOConstructor constr)
 	{
 		OperationType[] ops = constr.operation();
 		Arrays.sort(ops);
 		if (Arrays.binarySearch(ops, operation) >= 0)
 		{
 			return true;
 		}
 		return Arrays.binarySearch(ops, OperationType.ALL) >= 0;
 	}
 	
 }