/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common is free software: you can redistribute it and/or modify
    * it under the terms of the GNU General Public License as published by
    * the Free Software Foundation, either version 3 of the License, or
    * (at your option) any later version.
   *
   * Java-Common 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
   * GNU General Public License for more details.
   *
   * You should have received a copy of the GNU General Public License
   * along with Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.introspection;
  
  import java.beans.IntrospectionException;
  import java.beans.Introspector;
  import java.beans.MethodDescriptor;
  import java.beans.ParameterDescriptor;
  import java.lang.reflect.Constructor;
  import java.lang.reflect.Field;
  import java.lang.reflect.Member;
  import java.lang.reflect.Method;
  import java.lang.reflect.Modifier;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.Comparator;
  import java.util.HashSet;
  
  /**
   * This class provides helper methods to easily manipulate an analyze
   * classes and their members.
   * 
   * @author Miha Kadunc
   */
  public class ClassIntrospector {
  
    public static Method getMethod(Class targetClass, String name,Class[] paramTypes) {
    	Method ret=null;
  	try {
  		 ret=targetClass.getMethod(name,paramTypes);
  	}
  	catch (NoSuchMethodException e) {
  	}
    	return ret;
    }
    
    public static Class forName(String className) throws ClassNotFoundException {
    	if (className.indexOf('.')!=-1 || className.indexOf('[')!=-1) return Class.forName(className);
    	if (className.equals("short")) {
    		return Short.TYPE;
    	} else if (className.equals("byte")) {
    		return Byte.TYPE;
  		} else if (className.equals("char")) {
  			return Character.TYPE;
  		} else if (className.equals("boolean")) {
  			return Boolean.TYPE;
  		} else if (className.equals("int")) {
  			return Integer.TYPE;
  		} else if (className.equals("float")) {
  			return Float.TYPE;
  		} else if (className.equals("void")) {
  			return Void.TYPE;
  		} else if (className.equals("double")) {
  			return Double.TYPE;
  		} else if (className.equals("long")) {
  			return Long.TYPE;
    	}
    	throw new IllegalArgumentException("Cannot parse string "+className);
    }
    
    /**
     * Returns declared members of the specified class. By setting the fields,
     * constructors or methods flags users can choose whether the returned members should
     * contain these items.
     * 
     * 
     * @param theClass Class
     * @param fields boolean
     * @param constructors boolean
     * @param methods boolean
     * @return Member[]
     */
    public static Member[] getDeclaredMembers(
      Class theClass,
      boolean fields,
      boolean constructors,
      boolean methods) {
      if (theClass == null)
        throw new NullPointerException("theClass");
      ArrayList list = new ArrayList();
  
      if (methods) {
       list.addAll(Arrays.asList(theClass.getDeclaredMethods()));
     }
 
     if (fields) {
       list.addAll(Arrays.asList(theClass.getDeclaredFields()));
     }
 
     if (constructors) {
       list.addAll(Arrays.asList(theClass.getDeclaredConstructors()));
     }
     Member[] retVal = new Member[list.size()];
     list.toArray(retVal);
     return retVal;
   }
   /**
    * Identifies the Java Enum pattern.
    * 
    * @param theClass - the class that is to be inspected
    * @return boolean
    */
   public static boolean isEnum(Class theClass) {
     boolean ret = false;
     if (theClass.getConstructors().length == 0) {
       Field[] fields = theClass.getFields();
       if (fields.length>0) ret=true;
       for (int i = 0; i < fields.length; i++) {
         if (Modifier.isPublic(fields[i].getModifiers()))
           if (!(fields[i].getType().equals(theClass)))
             ret = false;
       }
     }
     return ret;
   }
   
 	/**
 	 * @param primitiveType
 	 * @return the wrapper of the passed primitive type.
 	 */
 	public static Class getPrimitiveWrapper(Class primitiveType){
 		if (primitiveType==Boolean.TYPE){
 			return Boolean.class;
 		} else if (primitiveType==Byte.TYPE){
 			return Byte.class;
 		} else if (primitiveType==Character.TYPE){
 			return Character.class;
 		} else if (primitiveType==Short.TYPE){
 			return Short.class;
 		} else if (primitiveType==Integer.TYPE){
 			return Integer.class;
 		} else if (primitiveType==Long.TYPE){
 			return Long.class;
 		} else if (primitiveType==Float.TYPE){
 			return Float.class;
 		} else if (primitiveType==Double.TYPE){
 			return Double.class;			
 		} else if (primitiveType==Void.TYPE){
 			return Void.class;	
 		}		
 		else throw new IllegalArgumentException("Type should be primitive. "+primitiveType+" is not");
 	}
 	
 	public static boolean isPrimitiveWrapper(Class wrapperType) {
 		if ((wrapperType==Boolean.class) ||
 				(wrapperType==Byte.class) ||
 				(wrapperType==Character.class) ||
 				(wrapperType==Short.class) ||
 				(wrapperType==Integer.class) ||
 				(wrapperType==Long.class) ||
 				(wrapperType==Float.class) ||
 				(wrapperType==Double.class))
 			return true;			
 		else return false;
 	}
   /**
    * Determines whether the <code>objectType</code> class can be used in
    * introspection operations to set a value which is declared
    * to be of the <code>targetType</code> class.
    * <p>
    * This method returns <code>targetType.isAssignableFrom(objectType)</code>
    * for object types, and also returns true when <code>targetType</code>
    * is primitive and <code>objectType</code> is its object wrapper.
    */
   public static boolean isCompatible(Class objectType, Class targetType){
   	if (targetType.isAssignableFrom(objectType)) return true;
   	else if (targetType.isPrimitive()) {
   		return (objectType.equals(getPrimitiveWrapper(targetType)));
   	}
   	else return false;
   }
 
   /**
    * Returns array of fields are decleared by Java Enum pattern.
    * 
    * @param theClass - the class that is to be inspected and interpreted as enum
    * @return array of enum <code>java.lang.reflect.Field</code> objects
    */
   public static Field[] getEnumFields(Class theClass) {
     if (theClass.getConstructors().length == 0) {
       ArrayList newFields=new ArrayList();
       boolean ret = true;
       Field[] fields = theClass.getFields();
       for (int i = 0; i < fields.length; i++) {
         if (Modifier.isPublic(fields[i].getModifiers()) && Modifier.isStatic(fields[i].getModifiers())&& Modifier.isFinal(fields[i].getModifiers())){
           if (!(fields[i].getType().equals(theClass))){
             ret = false;
           }
           else {
             newFields.add(fields[i]);
           }
         }
       }
       if (ret)
         return (Field[])newFields.toArray(new Field[newFields.size()]);
     }
     return null;
   }
 
   /**
    * If class can be interpreted as Java enum pattern, then returns array this class instances as they would be enums. Method tries to order them by <code>value()</code> field. 
    * 
    * @param theClass - the class that is to be inspected and interpreted as enum
    * @return array of enum instances objects
    */
   public static Object[] getEnums(Class theClass) throws IllegalAccessException{
   	Field[] f= getEnumFields(theClass);
   	if (f==null) return null;
   	
   	Object[] o= new Object[f.length];
 
 		for (int i = 0; i < o.length; i++) {
 			o[i]= f[i].get(null);
 		}
   	
 		Method m=null;
 		
   	try {
   		m= getMethod(theClass,"value",new Class[]{});
   		if (!m.getReturnType().equals(int.class)) {
   			m=null;
   		}
   	} catch (Exception e) {
   		//
   	}
   	
   	if (m!=null) {
   		final Method mm=m;
   		
   		Arrays.sort(o,new Comparator() {
 			public boolean equals(Object obj) {
 				return false;
 			}
 
 			public int compare(Object o1, Object o2) {
 				try {
 				return ((Number)mm.invoke(o1,new Object[0])).intValue()-((Number)mm.invoke(o2,new Object[0])).intValue();
 				} catch (Exception e) {
 					return 0;
 				}
 			}
 		});
   	}
   	
   	return o;
   	
   }
   	
   	/**
    * Selects members that have the specified modifiers from an array
    * of <code>Member</code> instances.
    * 
    * @param members Member[]
    * @param modifiers int - as specified by the java.lang.reflect.Modifier
    * @return Member[]
    */
   public static Member[] getForModifiers(Member[] members, int modifiers) {
     ArrayList list = new ArrayList();
     System.out.println(Modifier.toString(modifiers) + "<---" + modifiers);
     for (int i = 0; i < members.length; i++) {
       if (areInModifiers(members[i].getModifiers(), modifiers))
         list.add(members[i]);
     }
     Member[] retVal = new Member[list.size()];
     list.toArray(retVal);
     return retVal;
   }
   /**
    * Returns all members (methods and constructors) that take the same parameters.
    * 
    * @param members Member[]
    * @param parameterTypes Class[]
    * @return Member[]
    */
   public static Member[] getForParameterTypes(Member[] members, Class[] parameterTypes) {
     ArrayList list = new ArrayList();
     for (int i = 0; i < members.length; i++) {
       if ((members[i] instanceof Method)
         && (((Method) members[i]).getParameterTypes().equals(parameterTypes)))
         list.add(members[i]);
       else if (
         (members[i] instanceof Constructor)
           && (((Constructor) members[i]).getParameterTypes().equals(parameterTypes)))
         list.add(members[i]);
     }
     Member[] retVal = new Member[list.size()];
     list.toArray(retVal);
     return retVal;
   }
   /**
    * Returns all members (methods and fields) that have the same declared
    * return type (or field type).
    * 
    * @param members Member[]
    * @param returnType Class
    * @return Member[]
    */
   public static Member[] getForReturnType(Member[] members, Class returnType) {
     ArrayList list = new ArrayList();
     for (int i = 0; i < members.length; i++) {
       if ((members[i] instanceof Method)
         && (((Method) members[i]).getReturnType().equals(returnType)))
         list.add(members[i]);
       else if (
         (members[i] instanceof Field) && (((Field) members[i]).getType().equals(returnType)))
         list.add(members[i]);
     }
     Member[] retVal = new Member[list.size()];
     list.toArray(retVal);
     return retVal;
   }
   /**
    * Returns all members of the specified class. By setting the fields,
    * constructors or methods flags users can choose whether the returned members should
    * contain these items.
    * 
    * @param theClass Class
    * @param fields boolean
    * @param constructors boolean
    * @param methods boolean
    * @return Member[]
    */
   public static Member[] getMembers(
     Class theClass,
     boolean fields,
     boolean constructors,
     boolean methods) {
     if (theClass == null)
       throw new NullPointerException("theClass");
     HashSet set = new HashSet();
     set.addAll(Arrays.asList(getDeclaredMembers(theClass, constructors, fields, methods)));
     if (methods) {
       set.addAll(Arrays.asList(theClass.getMethods()));
     }
 
     if (fields) {
       set.addAll(Arrays.asList(theClass.getFields()));
     }
 
     if (constructors) {
       set.addAll(Arrays.asList(theClass.getConstructors()));
     }
     Member[] retVal = new Member[set.size()];
     set.toArray(retVal);
     return retVal;
   }
   /**
    * Returns all private members from an array of <code>Member</code> instances.
    * 
    * @param members Member[]
    * @return Member[]
    */
   public static Member[] getPrivate(Member[] members) {
     ArrayList list = new ArrayList();
     for (int i = 0; i < members.length; i++) {
       if (Modifier.isPrivate(members[i].getModifiers()))
         list.add(members[i]);
     }
     Member[] retVal = new Member[list.size()];
     list.toArray(retVal);
     return retVal;
   }
   /**
    * Returns all protected members from an array of <code>Member</code> instances.
    * 
    * @param members Member[]
    * @return Member[]
    */
   public static Member[] getProtected(Member[] members) {
     ArrayList list = new ArrayList();
     for (int i = 0; i < members.length; i++) {
       if (Modifier.isProtected(members[i].getModifiers()))
         list.add(members[i]);
     }
     Member[] retVal = new Member[list.size()];
     list.toArray(retVal);
     return retVal;
   }
   /**
    * Returns all public members from an array of <code>Member</code> instances.
    * 
    * @param members Member[]
    * @return Member[]
    */
   public static Member[] getPublic(Member[] members) {
     ArrayList list = new ArrayList();
     for (int i = 0; i < members.length; i++) {
       if (Modifier.isPublic(members[i].getModifiers()))
         list.add(members[i]);
     }
     Member[] retVal = new Member[list.size()];
     list.toArray(retVal);
     return retVal;
   }
   /**
    * Returns all public members of the specified class. By setting the fields,
    * constructors or methods flags users can choose whether the returned members should
    * contain these items.
    * 
    * @param theClass Class
    * @param fields boolean
    * @param constructors boolean
    * @param methods boolean
    * @return Member[]
    */
   public static Member[] getPublicMembers(
     Class theClass,
     boolean fields,
     boolean constructors,
     boolean methods) {
     if (theClass == null)
       throw new NullPointerException("theClass");
     ArrayList list = new ArrayList();
 
     if (methods) {
       list.addAll(Arrays.asList(theClass.getMethods()));
     }
 
     if (fields) {
       list.addAll(Arrays.asList(theClass.getFields()));
     }
 
     if (constructors) {
       list.addAll(Arrays.asList(theClass.getConstructors()));
     }
     Member[] retVal = new Member[list.size()];
     list.toArray(retVal);
     return retVal;
   }
   /**
    * Returns names of parameters of a given method.
    * 
    * @param m Member
    * @return String[]
    */
   public static String[] getParameterNames(Member m) {
     if (m instanceof Method) {
       String[] ret;
 
       try {
         MethodDescriptor md =
           (MethodDescriptor) BeanIntrospector.getDescriptor(
             Introspector.getBeanInfo(m.getDeclaringClass()).getMethodDescriptors(),
             m);
         if (md != null) {
           ParameterDescriptor[] pds = md.getParameterDescriptors();
           if ((pds != null) && (pds.length == ((Method) m).getParameterTypes().length)) {
             ret = DataFormatter.toStringArray(pds, false, false);
             return ret;
           }
         }
       } catch (IntrospectionException e) {
 
       }
       int len = ((Method) m).getParameterTypes().length;
       ret = new String[len];
       for (int i = 0; i < ret.length; i++) {
         ret[i] = "arg" + i;
       }
       return ret;
     }
     if (m instanceof Constructor) {
       int len = ((Constructor) m).getParameterTypes().length;
       String[] ret = new String[len];
       for (int i = 0; i < ret.length; i++) {
         ret[i] = "arg" + i;
       }
       return ret;
     }
     return null;
   }
 
   /**
    * Returns <code>true</code> if the <code>targetModifiers</code> contains all
    * of the specified <code>modifiers<code>.
    * 
    * @param targetModifiers int
    * @param modifiers int
    * @return boolean
    */
   public static boolean areInModifiers(int targetModifiers, int modifiers) {
     return true;
   }
 
   /**
    * Returns all members of the specified class that are accepted by the <code>filter</code>
    * object passed as a parameter.
    * 
    * @param theClass Class
    * @param filter MemberFilter
    * @return Member[]
    */
   public static Member[] getMembers(Class theClass, MemberFilter filter) {
     if (theClass == null)
       throw new NullPointerException("theClass");
     HashSet set = new HashSet();
     if (filter == null)
       return getMembers(theClass, true, true, true);
     if (filter.areFieldsAllowed())
       internalGetFields(set, theClass, filter);
     if (filter.areConstructorsAllowed())
       internalGetConstructors(set, theClass, filter);
     if (filter.areMethodsAllowed())
       internalGetMethods(set, theClass, filter);
     Member[] retVal = new Member[set.size()];
     set.toArray(retVal);
     return retVal;
   }
 
   /**
    * Creation date: (12.1.2002 1:18:43)
    */
   private static void internalGetConstructors(HashSet set, Class theClass, MemberFilter filter) {
     if (filter == null) {
       set.addAll(Arrays.asList(theClass.getConstructors()));
       return;
     } else {
       Member[] members = null;
 
       if (!filter.areDeclaredOnly()) {
         members = theClass.getConstructors();
         for (int i = 0; i < members.length; i++) {
           if (filter.isAllowed(members[i]))
             set.add(members[i]);
         }
         if (filter.arePublicOnly())
           return;
       }
 
       members = theClass.getDeclaredConstructors();
       for (int i = 0; i < members.length; i++) {
         if (filter.isAllowed(members[i]))
           set.add(members[i]);
       }
     }
   }
 
   /**
    * Creation date: (12.1.2002 1:18:43)
    */
   private static void internalGetFields(HashSet set, Class theClass, MemberFilter filter) {
     if (filter == null) {
       set.addAll(Arrays.asList(theClass.getFields()));
       return;
     } else {
       Member[] members = null;
 
       if (!filter.areDeclaredOnly()) {
         members = theClass.getFields();
         for (int i = 0; i < members.length; i++) {
           if (filter.isAllowed(members[i]))
             set.add(members[i]);
         }
         if (filter.arePublicOnly())
           return;
       }
 
       members = theClass.getDeclaredFields();
       for (int i = 0; i < members.length; i++) {
         if (filter.isAllowed(members[i]))
           set.add(members[i]);
       }
     }
   }
 
   /**
    * Creation date: (12.1.2002 1:18:43)
    */
   private static void internalGetMethods(HashSet set, Class theClass, MemberFilter filter) {
     if (filter == null) {
       set.addAll(Arrays.asList(theClass.getMethods()));
       return;
     } else {
       Member[] members = null;
 
       if (!filter.areDeclaredOnly()) {
         members = theClass.getMethods();
         for (int i = 0; i < members.length; i++) {
           if (filter.isAllowed(members[i]))
             set.add(members[i]);
         }
         if (filter.arePublicOnly())
           return;
       }
 
       members = theClass.getDeclaredMethods();
       for (int i = 0; i < members.length; i++) {
         if (filter.isAllowed(members[i]))
           set.add(members[i]);
       }
     }
   }
 
 }