package org.sourceforge.jemm.client;
   
   import java.lang.reflect.Field;
   import java.lang.reflect.Method;
   
   import org.sourceforge.jemm.database.FieldType;
   import org.sourceforge.jemm.lifecycle.AttributeUse;
   import org.sourceforge.jemm.lifecycle.ShadowData;
   import org.sourceforge.jemm.lifecycle.ShadowObject;
  import org.sourceforge.jemm.lifecycle.ShadowUserObject;
  import org.sourceforge.jemm.lifecycle.Uses;
  import org.sourceforge.jemm.types.ID;
  import org.sourceforge.jemm.util.JEMMObject;
  
  /**
   * An Entity is a JEMMObject representation that allows low level access to the
   * fields, methods and constructors.
   * 
   * This interfaces implementations allows manipulation of a JEMMObject and have
   * intricate knowledge of what the compiler has added to the JEMMObject
   * entities.
   * 
   * @See EntityAccessor Accesses the JEMMObject using reflection
   * @See ShadowDataEntity Stores Object data as IDs in a Shadow Map
   * 
   * @author Paul Keeble
   * 
   */
  public class Entity {
  	JEMMObject obj;
  	
  	public Entity(JEMMObject obj) {
  		this.obj = obj;
  	}
  	
  	/**
  	 * Returns the referenced ShadowObject on the Enhanced Object referenced.
  	 * 
  	 * @return The ShadowObject the object currently uses.
  	 */
  	public ShadowUserObject getShadowUserObject() {
  		ShadowObject so = getShadowObject();
  		return (ShadowUserObject) so;
  	}
  
  	/**
  	 * Returns the referenced ShadowObject on the Enhanced Object referenced.
  	 * 
  	 * @return The ShadowObject the object currently uses.
  	 */
  	public ShadowObject getShadowObject() {
  		try {
  			ClassHierarchyIterator iterator = new ClassHierarchyIterator(obj.getClass());
  			Class<?> parent=null;
  			while(iterator.hasNext())
  				parent = iterator.next();
  			
  			Field f = parent.getDeclaredField("jemmOIF");
  			f.setAccessible(true);
  			return (ShadowObject)f.get(obj);
  		} catch (Exception e) {
  			throw new RuntimeException(e);
  		}
  	}
  
  	
  	public ShadowData getShadowData() {
  		return getShadowUserObject().getData();
  	}
  	
  	public int getVersion() {
  		return getShadowData().getVersion();
  	}
  	
  	public void setVersion(int newVersion) {
  		getShadowData().setVersion(newVersion);
  	}
  	
  	/**
  	 * Sets the ShadowObject that is defined on underlying object
  	 * 
  	 * @param so
  	 *            The new ShadowObject
  	 */
  	public void setShadowObject(ShadowUserObject so) {
  		try {
  			ClassHierarchyIterator iterator = new ClassHierarchyIterator(obj.getClass());
  			for(Class<?> clazz : iterator) {
  				try {
  					Field f = clazz.getDeclaredField("jemmOIF");
  					f.setAccessible(true);
  					f.set(obj, so);
  				}catch (NoSuchFieldException e) {
  					//ignore
  				}
  			}
  		} catch (Exception e) {
  			throw new RuntimeException(e);
  		}
 	}
 	
 	/**
 	 * Returns the ID of the JEMMObject as held by the ShadowObject
 	 * 
 	 * @return The ID of the object
 	 */
 	public ID getID() {
 		return getShadowObject().getID();
 	}
 	
 	/**
 	 * Sets the field on the JEMMObject, without changing the ShadowMap.
 	 * 
 	 * In a hierarchy of classes the sae field can be declared multiple times. A
 	 * private field for instance is not overriden in the sub classes
 	 * 
 	 * @param className
 	 *            The name of the class that declares the field
 	 * @param fieldName
 	 *            The name of the field to access
 	 * @param value
 	 *            The value to set the field to
 	 */
 	public void setField(FieldKey fkey, Object value) {
 		try {
 			Class<?> c = fkey.getClazz();
 			Field f = c.getDeclaredField(fkey.getName());
 			f.setAccessible(true);
 			f.set(obj, value);
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	/**
 	 * Gets the field as it is on the JEMMObject, without consulting the
 	 * ShadowMap
 	 * 
 	 * @param className
 	 * @param fieldName
 	 */
 	public Object getField(FieldKey fkey) {
 		try {
 			Class<?> c = fkey.getClazz();
 			Field f = c.getDeclaredField(fkey.getName());
 			f.setAccessible(true);
 			Object value = f.get(obj);
 			return value;
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		} 
 	}
 	
 	/**
 	 * Determines the Type of a field.
 	 * 
 	 * @param fKey The unique identifying key for a field
 	 * @return The Type of the field
 	 */
 	public FieldType getFieldType(FieldKey fKey) {
 		try {
 			Field f = fKey.getField();
 			return FieldType.convert(f.getType());
 		} catch(Exception e) {
 			throw new RuntimeException(e);
 		}
 		
 	}
 
 	/**
 	 * Reads any Uses annotations on a method which define which fields should
 	 * be initialised.
 	 * 
 	 * @param methodSignature
 	 *            The method to read the annotations from./
 	 * @return The names of the methods
 	 */
 	public AttributeUse[] methodUses(Descriptor methodSignature) {
 		try {
 			Method m = 
 				methodSignature.getMethod();
 			Uses uses = m.getAnnotation(Uses.class);
 			if(uses==null)
 				return new AttributeUse[0];
 			return uses.value();
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 }