package org.sourceforge.jemm.weaver.transformation.field;
   
   import java.util.HashSet;
   import java.util.Set;
   
   import javassist.CtClass;
   import javassist.CtField;
   import javassist.NotFoundException;
   import javassist.bytecode.Descriptor;
  
  import org.sourceforge.jemm.Entity;
  import org.sourceforge.jemm.collections.JemmList;
  import org.sourceforge.jemm.collections.JemmMap;
  import org.sourceforge.jemm.collections.JemmSet;
  import org.sourceforge.jemm.util.JEMMObject;
  import org.sourceforge.jemm.weaver.transformation.ClassPoolFactory;
  import org.sourceforge.jemm.weaver.transformation.ShadowTransformation;
  
  /**
   * Determines if a field on a class is either a jemm created field
   * or specifically using the JEMM API and hence should be ignored.
   * 
   * @author <a href="mailto:csuml@yahoo.co.uk">Paul Keeble</a>
   *
   */
  public class FieldClassifier {
  	Set<String> jemmClasses;
  	Set<String> primitiveDescriptors;
  	Set<String> knownImmutables;
  
  	/**
  	 * A classification of a CtField as needed by the transformation process.
  	 *
  	 */
  	public enum Classification {
  	    /** A Jemm Collection type. */
  	    COLLECTION,
  	    /** A Shadow object field. */
  	    SHADOW,
  	    /** A known valid immutable type (String,Integer,Long etc.) */
  	    KNOWNIMMUTABLE,
  	    /** A supported reference type (typically to another JemmObject type. */
  	    SUPPORTED,
  	    /** A field that doesn't fall into any other category. */
  	    NORMALOBJECT,
  	    /** A primitive type field. */	   
  	    PRIMITIVE,
  	    /** A field that has already been transformed for internal use. */
  	    ALREADYTRANSFORMED
      }
  	
  	/**
  	 * Creates a new instance of a FieldClassifier.
  	 */
  	public FieldClassifier() {
  		jemmClasses = new HashSet<String>();
  		jemmClasses.add(Descriptor.of(JemmList.class.getName()));
  		jemmClasses.add(Descriptor.of(JemmMap.class.getName()));
  		jemmClasses.add(Descriptor.of(JemmSet.class.getName()));
  		
  		primitiveDescriptors = new HashSet<String>();
  		primitiveDescriptors.add(Descriptor.of(CtClass.shortType));
  		primitiveDescriptors.add(Descriptor.of(CtClass.intType));
  		primitiveDescriptors.add(Descriptor.of(CtClass.longType));
  		primitiveDescriptors.add(Descriptor.of(CtClass.floatType));
  		primitiveDescriptors.add(Descriptor.of(CtClass.doubleType));
  		primitiveDescriptors.add(Descriptor.of(CtClass.booleanType));
  		primitiveDescriptors.add(Descriptor.of(CtClass.byteType));
  		primitiveDescriptors.add(Descriptor.of(CtClass.charType));
  		
  		knownImmutables = new HashSet<String>();
  		knownImmutables.add(Descriptor.of("java.lang.Short"));
  		knownImmutables.add(Descriptor.of("java.lang.Integer"));
  		knownImmutables.add(Descriptor.of("java.lang.Long"));
  		knownImmutables.add(Descriptor.of("java.lang.Float"));
  		knownImmutables.add(Descriptor.of("java.lang.Double"));
  		knownImmutables.add(Descriptor.of("java.lang.Boolean"));
  		knownImmutables.add(Descriptor.of("java.lang.Byte"));
  		knownImmutables.add(Descriptor.of("java.lang.Character"));
  		knownImmutables.add(Descriptor.of("java.lang.String"));
          knownImmutables.add(Descriptor.of("org.sourceforge.jemm.types.JemmDate"));
  	}
  	
  	/**
  	 * Classifies the passed in field into a number of different states so that the compiler
  	 * can determine what to do with a particular field.
  	 * 
  	 * @param field The field to check
  	 * @return A classification of the field
  	 * @throws NotFoundException
  	 */
  	public Classification classifySingular(CtField field) throws NotFoundException {
  		CtClass type = field.getType();
  		String fieldName = field.getName();
  		
  		if(isPrimitive(field))
  			return Classification.PRIMITIVE;
  		if(isJemmCollection(field))
  			return Classification.COLLECTION;
 		else if (fieldName.equals(ShadowTransformation.SHADOW_VARIABLE_NAME) 
 				&& type.getName().equals(ShadowTransformation.SHADOW_CLASS))
 			return Classification.SHADOW;
 		else if (isKnownImmutable(field))
 			return Classification.KNOWNIMMUTABLE;
 		else if (type.subtypeOf(ClassPoolFactory.getPool().get(JEMMObject.class.getName()))
 				|| type.subtypeOf(ClassPoolFactory.getPool().get(JEMMObject.class.getName() + "[]")))
 			return Classification.SUPPORTED;
 		else if (isEntity(field)) 
 			return Classification.SUPPORTED;
 		return Classification.NORMALOBJECT;
 	}
 	
 	/**
 	 * Returned whether the type referred to by the field is another entity (jemm object).
 	 * @param field The target field.
 	 * @return True if the field is an entity type, false otherwise.
 	 */
 	public boolean isEntity(CtField field){
 		Object[] annotations;
 		try {
 			CtClass type = field.getType().isArray() ?  field.getType().getComponentType() : field.getType();
 			annotations = type.getAnnotations();
 		} catch (Exception e) {
 			throw new RuntimeException("Couldn't find Entity class, shouldn't be possible");
 		}
 		for(Object each : annotations) {
 			if(Entity.class.isInstance(each))
 				return true;
 		}
 		return false;
 	}
 	
 	/**
 	 * Is a special field if the field is the shadow object or has the class type
 	 * of one of the Jemm Collections.
 	 * 
 	 * @param field The field to check
 	 * @return true if the field is Jemm specific, false otherwise.
 	 * @throws NotFoundException ClassPool JA exception if the CtClass can't be found.
 	 */
 	public boolean isJemmSpecialField(CtField field) throws NotFoundException {
 		Classification c = classifySingular(field);
 		return c == Classification.COLLECTION || c == Classification.SHADOW;
 	}
 	
 	/**
 	 * If a field can be converted to a JEMMReference then this returns true, else false
 	 * @param field the field to check
 	 * @return true if convertable, else false.
 	 * @throws NotFoundException
 	 */
 	public boolean isJEMMReferenceTransformable(CtField field) throws NotFoundException {
 		Classification c = classifySingular(field);
 		return c == Classification.SUPPORTED && !isArray(field);
 	}
 	
 	/**
 	 * If an array field can be converted to a JEMMArrayReference then this returns true, else false.
 	 * 
 	 * Arrays of NORMALOBJECT, primatives, Strings and JemmObject's should be supported.
 	 * 
 	 * @param field The field to check
 	 * @return true if convertable, else false
 	 * @throws NotFoundException
 	 */
 	public boolean isArrayReferenceTransformable(CtField field) throws NotFoundException {
 		Classification c = classifySingular(field);
 		return c == Classification.SUPPORTED && isArray(field);
 	}
 	
 	/**
 	 * Returns the dimensions of an array field type.
 	 * @param field The target field.
 	 * @return The number of array dimensions.
 	 * @throws NotFoundException In an internal error occurs whilst loading the field type.
 	 */
 	public int arrayDimensions(CtField field) throws NotFoundException {
 		String desc = Descriptor.of(field.getType());
 		return Descriptor.arrayDimension(desc);
 	}
 	
 	/**
 	 * Returns whether the given field is an array type.
 	 * @param field The target field.
 	 * @return True if the target field is an array type, false otherwise.
      * @throws NotFoundException In an internal error occurs whilst loading the field type.
 	 */
 	public boolean isArray(CtField field) throws NotFoundException {
 		return field.getType().isArray();
 	}
 	
 	/**
 	 * If the field is a Jemm specific type then this returns true, else false.
 	 * 
 	 * Jemm specific types include all the Collections.
 	 * 
 	 * @param field The field to check the type of
 	 * @return true if the field is a jemm type, false otherwise
      * @throws NotFoundException In an internal error occurs whilst loading the field type.
 	 */
 	public boolean isJemmCollection(CtField field) throws NotFoundException {
 		String fieldType = underlyingDescriptor(field);
 		
 		return jemmClasses.contains(fieldType);
 	}
 	
 	/**
 	 * Returns the Descriptor of a field, but removes any ['s before
 	 * the descriptor that signify arrays.
 	 * 
 	 * @param field The field to determine the descriptor of
 	 * @return The underlying type descriptor
 	 */
 	private String underlyingDescriptor(CtField field) throws NotFoundException {
 		String fieldDesc = Descriptor.of(field.getType());
 		
 		int toIgnoreCharacters = arrayDimensions(field);
 		String adjustedDescriptor = fieldDesc.substring(toIgnoreCharacters);
 		return adjustedDescriptor;
 	}
 	
 	/**
 	 * Uses the descriptors to determine if the type of the field is a primitive, 
 	 * even if it is an array this will return true if the type of the array is
 	 * based on a primitive.
 	 * 
 	 * @param field The field to check
 	 * @return true if a primitive, false otherwise
 	 * @throws NotFoundException
 	 */
 	public boolean isPrimitive(CtField field) throws NotFoundException {
 		String fieldType = underlyingDescriptor(field);
 		
 		return primitiveDescriptors.contains(fieldType);
 	}
 	
 	/**
 	 * The wrapper types for the Primitives (Integer, Long, Float etc)
 	 * are covered by this definition as are the Jemm special immutable types
 	 * such as JemmDate.
 	 * 
 	 * @param field The field to test
 	 * @return true if it is a known immutable, else false.
      * @throws NotFoundException In an internal error occurs whilst loading the field type.
 	 */
 	public boolean isKnownImmutable(CtField field) throws NotFoundException {
 		String fieldType = underlyingDescriptor(field);
 		
 		return knownImmutables.contains(fieldType);
 	}
 }