/**
    * 
    */
   package ar.com.jiji.kaya.reflect;
   
   import java.lang.reflect.Constructor;
   import java.lang.reflect.InvocationTargetException;
   import java.lang.reflect.Method;
   import java.util.ArrayList;
  import java.util.List;
  import java.util.Map;
  import java.util.regex.Matcher;
  import java.util.regex.Pattern;
  
  import org.apache.commons.beanutils.BeanUtils;
  
  import ar.com.jiji.kaya.utils.ValidateUtils;
  
  /**
   * @author lparra
   * @version $Revision$ $Date$
   */
  public class ReflectionService {
  
  	private ReflectionService() {
  	}
  
  	public static Object newInstance(Class clazz) throws ReflectionException {
  		return newInstance(clazz, (Class[]) null, null);
  	}
  
  	public static Object newInstance(Class clazz, Class argType, Object arg)
  			throws ReflectionException {
  		return newInstance(clazz, new Class[] { argType }, new Object[] { arg });
  	}
  
  	@SuppressWarnings("unchecked")
  	public static Object newInstance(Class clazz, Class[] argTypes,
  			Object[] args) throws ReflectionException {
  		try {
  			Object result;
  			if (argTypes == null || argTypes.length == 0)
  				result = clazz.newInstance();
  			else {
  				Constructor c = clazz.getConstructor(argTypes);
  				result = c.newInstance(args);
  			}
  			return result;
  		} catch (InstantiationException e) {
  			throw new ReflectionException(e);
  		} catch (IllegalAccessException e) {
  			throw new ReflectionException(e);
  		} catch (SecurityException e) {
  			throw new ReflectionException(e);
  		} catch (NoSuchMethodException e) {
  			throw new ReflectionException(e);
  		} catch (IllegalArgumentException e) {
  			throw new ReflectionException(e);
  		} catch (InvocationTargetException e) {
  			throw new ReflectionException(e);
  		}
  	}
  
  	public static Object invoke(String methodName, Object obj)
  			throws ReflectionException {
  		return invoke(methodName, (Class) null, obj, null);
  	}
  
  	public static Object invoke(String methodName, Class argClass, Object obj,
  			Object arg) throws ReflectionException {
  		Class[] argsClasses = (argClass == null ? (Class[]) null
  				: new Class[] { argClass });
  		Object[] args = (arg == null ? (Object[]) null : new Object[] { arg });
  		return invoke(methodName, argsClasses, obj, args);
  	}
  
  	private static Method getMethod(Object obj, String methodName,
  			Class[] argsClasses) throws ReflectionException {
  		ValidateUtils.notNull(obj);
  		ValidateUtils.notNull(methodName);
  
  		try {
  			return obj.getClass().getMethod(methodName, argsClasses);
  		} catch (SecurityException e) {
  			throw new ReflectionException(e);
  		} catch (NoSuchMethodException e) {
  			throw new ReflectionException(e);
  		}
  	}
  
  	public static Object invoke(String methodName, Class[] argsClasses,
  			Object obj, Object[] args) throws ReflectionException {
  		ValidateUtils.notNull(obj);
  		ValidateUtils.notNull(methodName);
  
  		try {
  			final Method m = getMethod(obj, methodName, argsClasses);
  			return m.invoke(obj, args);
  		} catch (SecurityException e) {
 			throw new ReflectionException(e);
 		} catch (IllegalArgumentException e) {
 			throw new ReflectionException(e);
 		} catch (IllegalAccessException e) {
 			throw new ReflectionException(e);
 		} catch (InvocationTargetException e) {
 			throw new ReflectionException(e);
 		}
 	}
 
 	public static Object invoke(String methodName, Class argClass, Object obj,
 			Object arg, Class returningType) throws ReflectionException {
 		Class[] argsClasses = (argClass == null ? (Class[]) null
 				: new Class[] { argClass });
 		Object[] args = (arg == null ? (Object[]) null : new Object[] { arg });
 		return invoke(methodName, argsClasses, obj, args, returningType);
 	}
 
 	public static Object invoke(String methodName, Class[] argsClasses,
 			Object obj, Object[] args, Class returningType)
 			throws ReflectionException {
 		try {
 			final Method m = getMethod(obj, methodName, argsClasses);
 			final Object result = m.invoke(obj, args);
 			if (result != null && !returningType.isInstance(result))
 				throw new ReflectionException(obj.getClass() + "." + methodName
 						+ " no devuelve " + returningType);
 			return result;
 		} catch (IllegalArgumentException e) {
 			throw new ReflectionException(e);
 		} catch (IllegalAccessException e) {
 			throw new ReflectionException(e);
 		} catch (InvocationTargetException e) {
 			throw new ReflectionException(e);
 		}
 	}
 
 	/**
 	 * Devuelve el valor de un property de un objeto.
 	 * 
 	 * @param obj
 	 *            No puede ser null
 	 * @param property
 	 *            No puede ser null
 	 * @return
 	 */
 	public static Object getProperty(Object obj, String property) {
 		return ReflectionService.invoke(MethodNames.getAccessor(property), obj);
 	}
 
 	/**
 	 * Obtiene el valor de un property y lo convierte a String antes de
 	 * devolverlo.
 	 * 
 	 * @param obj
 	 *            No puede ser null
 	 * @param property
 	 *            No puede ser null
 	 * @return
 	 * @see #getProperty(Object, String)
 	 */
 	public static String getPropertyAsString(Object obj, String property) {
 		Object o = getProperty(obj, property);
 
 		String result = null;
 		if (o != null)
 			result = o.toString();
 		return result;
 	}
 
 	/**
 	 * Devuelve el id del objeto. Supone que el objeto tiene una propiedad
 	 * llamada <code>id<code> que es un numero entero (Short, Byte, Integer,
 	 * Long). TODO: revisar con primitivos que pasa.
 	 *   
 	 * @param obj No puede ser null
 	 * @return
 	 * @see #getProperty(Object, String)
 	 */
 	public static Long getObjectId(Object obj) {
 		Long result = null;
 
 		Object aux = ReflectionService.getProperty(obj, "id");
 		if (aux != null) {
 			if (!((aux instanceof Short) || (aux instanceof Byte)
 					|| (aux instanceof Integer) || (aux instanceof Long)))
 				throw new ReflectionException("La propiedad id es "
 						+ aux.getClass() + " y se esperaba algun numero entero"
 						+ "(short, byte, int, long) o su wrapper");
 			result = ((Number) aux).longValue();
 		}
 
 		return result;
 	}
 
 	/**
 	 * Dado un objeto devuelve los nombres de los metodos que devuelven algun
 	 * objeto de tipo dao. Se asume que los metodos que devuelven los dao siguen
 	 * la convencion <code>getXDao</code> siendo <code>X</code> alguna
 	 * cadena no vacia.
 	 * 
 	 * @param obj
 	 *            El objeto a examinar, no puede ser null.
 	 * @return
 	 */
 	public static List<String> getDaoAccessors(Object obj) {
 		ValidateUtils.notNull(obj);
 
 		List<String> accessors = new ArrayList<String>();
 
 		Method[] facadem = obj.getClass().getMethods();
 		for (Method fm : facadem)
 			if (MethodNames.isAccessor(fm) && fm.getName().endsWith("Dao"))
 				accessors.add(fm.getName());
 
 		return accessors;
 	}
 
 	/**
 	 * Dado un objeto devuelve los nombres de los properties que devuelven algun
 	 * objeto de tipo facade. Se asume que los metodos que devuelven los facade
 	 * siguen la convencion <code>getXFacade</code> siendo <code>X</code>
 	 * alguna cadena no vacia.
 	 * 
 	 * @param obj
 	 *            El objeto a examinar, no puede ser null.
 	 * @return
 	 */
 	@SuppressWarnings("unchecked")
 	public static List<String> getFacadeAccessors(Object obj) {
 		ValidateUtils.notNull(obj);
 
 		List<String> accessors = new ArrayList<String>();
 
 		Map<String, Object> servicem;
 		try {
 			servicem = BeanUtils.describe(obj);
 		} catch (IllegalAccessException e) {
 			throw new ReflectionException(e);
 		} catch (InvocationTargetException e) {
 			throw new ReflectionException(e);
 		} catch (NoSuchMethodException e) {
 			throw new ReflectionException(e);
 		}
 		for (String sk : servicem.keySet())
 			if (sk.endsWith("Facade"))
 				accessors.add(sk);
 
 		return accessors;
 	}
 
 	/**
 	 * 
 	 * @param re
 	 * @param obj
 	 * @return
 	 * @see #getMethods(String, Class, Class)
 	 */
 	public static Method[] getMethods(String re, Object obj) {
 		return getMethods(re, obj, null);
 	}
 
 	/**
 	 * Devuelve todos los metodos cuyo nombre matcheen con la expresion regular
 	 * que se pasa de argumento.
 	 * 
 	 * @param re
 	 * @param obj
 	 *            El objeto a inspeccionar.
 	 * @param returnType
 	 *            El tipo que devuelve, null si no se desea realizar chequeo
 	 *            sobre el tipo devuelto.
 	 * @return Nunca es null.
 	 */
 	public static Method[] getMethods(String re, Object obj, Class returnType) {
 		ValidateUtils.notNull(re);
 
 		List<Method> aux = new ArrayList<Method>();
 
 		Pattern p = Pattern.compile(re);
 		for (Method m : obj.getClass().getDeclaredMethods()) {
 			Matcher matcher = p.matcher(m.getName());
 			if (matcher.matches()) {
 				if (returnType != null && m.getReturnType().equals(returnType))
 					aux.add(m);
 			}
 		}
 
 		return aux.toArray(new Method[] {});
 	}
 }