package org.sourceforge.jemm.client;
   
   import java.lang.reflect.Field;
   import java.util.HashMap;
   import java.util.Map;
   
   import org.sourceforge.jemm.JEMMInternalException;
   import org.sourceforge.jemm.client.types.FieldAccessor;
   import org.sourceforge.jemm.client.types.FieldAccessorChooser;
  import org.sourceforge.jemm.client.types.FieldTypeAccessorChooser;
  import org.sourceforge.jemm.database.FieldInfo;
  import org.sourceforge.jemm.database.FieldType;
  import org.sourceforge.jemm.lifecycle.AttributeUse;
  import org.sourceforge.jemm.lifecycle.MethodListener;
  import org.sourceforge.jemm.lifecycle.ShadowUserObject;
  import org.sourceforge.jemm.lifecycle.ShadowUserObjectImpl;
  import org.sourceforge.jemm.types.ID;
  import org.sourceforge.jemm.util.JEMMObject;
  
  /**
   * Accesses a JEMMObject enhanced class and provides access to the special
   * fields for common client functionality.
   * 
   * @author Paul Keeble
   * 
   */
  public class ObjectAccessor {
  	public static final int DEFAULT_VERSION = 0;
  	
  	JEMMObject obj;
  	FieldAccessorChooser accessorFactory;
  	
  	/**
  	 * Creates an Accessor to an enhanced object
  	 * 
  	 * @param obj The enhanced Object
  	 */
  	public ObjectAccessor(JEMMObject obj,ObjectSource database) {
  		this.obj = obj;
  		this.accessorFactory = new FieldTypeAccessorChooser(database,new Entity(obj));
  	}
  	
  	
  	
  	
  	/**
  	 * When an object is first created an ID and ShadowUserObject need to be assigned.
  	 * This method does the creation steps to get the obejct ready for JEMM tracking.
  	 * 
  	 */
  	public void create(ID id, MethodListener ml) {
  		
  		ShadowUserObject so = new ShadowUserObjectImpl(obj, ml, id,
  				DEFAULT_VERSION);
  		
  		Entity e = new Entity(obj);
  		e.setShadowObject(so);
  		initialiseObjectFields();
  	}
  	
  	public boolean isCreated() {
  		Entity e = new Entity(obj);
  		return e.getShadowObject()!=null;
  	}
  	
  	private void initialiseObjectFields() {
  		FieldIterator it = new FieldIterator(obj.getClass(),new JEMMObjectFilter());
  		for(Field field : it) {
  			setField(field.getDeclaringClass(),field.getName(),null);
  			initialiseField(field.getDeclaringClass(), field.getName());
  		}
  	}
  
  	/**
  	 * Sets the field to a value.
  	 * 
  	 * If the field is a primitive then the value is set on the object,
  	 * otherwise if its an JEMMObject then it is mapped in the ShadowData as the ID
  	 * of the object.
  	 * 
  	 * @param name
  	 *            The fields name
  	 * @param value
  	 *            The value to set the field to.
  	 */
  	public void setField(Class<?> declaringClass, String name, Object value) {
  		FieldKey fKey = new FieldKey(declaringClass,name);
  		
  		FieldAccessor fAccessor = accessorFactory.create(fKey);
  		fAccessor.setField(fKey, value);
  
  	}
  
  	/**
  	 * Gets the field value for the object.
  	 * 
  	 * If the field is a primitive then the value is retrieved from the JEMMObject.
  	 * Otherwise if it is a JEMMObject then the ID is returned.
  	 * 
 	 * @param declaringClass The class on which the field is found
 	 * @param name
 	 *            The field name
 	 * @param database The ObjectDatabase to retrieve the field from
 	 * 
 	 * @return A primitive object wrapper or ID
 	 */
 	public Object getField(Class<?> declaringClass,String name) {
 
 		FieldKey fKey = new FieldKey(declaringClass,name);
 		
 		FieldAccessor fAccessor = accessorFactory.create(fKey);
 		return fAccessor.getField(fKey);
 
 	}
 
 	/**
 	 * Initialises a JEMMObjects field to a real value.
 	 * 
 	 * If the field is an object then the ID is collected from the ShadowData, the object
 	 * is retrieved from the Object database and then set onto the object. If the field is
 	 * an array or primitive the field will be untouched.
 	 * 
 	 * @param declaringClass The class which delcared the field
 	 * @param fieldName
 	 *            The name of the field to set
 	 * @param database
 	 *            The place to retrieve the Object from
 	 */
 	public void initialiseField(String declaringClass, String fieldName) {
 		try {
 			initialiseField(Class.forName(declaringClass),fieldName);
 		} catch (ClassNotFoundException e) {
 			throw new JEMMInternalException("Programming error, class not found:" + declaringClass,e);
 		}
 	}
 	
 	public void initialiseField(Class<?> declaringClass,String fieldName) {
 		FieldKey fKey = new FieldKey(declaringClass,fieldName);
 
 		FieldAccessor fAccessor = accessorFactory.create(fKey);
 		fAccessor.initialise(fKey);
 	}
 	
 	public boolean isInitialised(Class<?> declaringClass,String fieldName) {
 		return new Entity(obj).getShadowData().
 			isFieldInitialised(declaringClass, FieldType.OBJECT, fieldName);
 	}
 	
 	public void initialiseAllFields(Descriptor methodDescriptor) {
 		try {
 			Entity e = new Entity(obj);
 			AttributeUse[] attribs = e.methodUses(methodDescriptor);
 			for(AttributeUse at : attribs) {
 				initialiseField(at.clazz(),at.name());
 			}
  		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 	}
 
 	/**
 	 * Clears an Objects field by setting it to null.
 	 * 
 	 * Only works on fields which are Objects, any primtives/array
 	 * will simply be left alone.
 	 * 
 	 * @param name
 	 *            The field name
 	 */
 	public void finaliseField(Class<?> declaringClass,String fieldName) {
 		try {
 			Field f = declaringClass.getDeclaredField(fieldName);
 			finaliseField(f);
 		} catch (Exception e) {
 			throw new RuntimeException(e);
 		}
 		
 	}
 	
 	public void finaliseField(Field f) {
 		if(f.getType().isPrimitive())
 			return;
 		FieldKey fKey = new FieldKey(f.getDeclaringClass(),f.getName());
 		FieldAccessor fAccessor = accessorFactory.create(fKey);
 		fAccessor.finalize(fKey);
 
 	}
 	
 	public void finaliseAllFields() {
 		FieldIterator it = new FieldIterator(obj.getClass(),new JEMMObjectFilter());
 		while(it.hasNext()) {
 			Field f = it.next();
 			finaliseField(f);
 		}
 		new Entity(obj).getShadowUserObject().getData().clearInitialisations();
 	}
 	
 	/**
 	 * Generates a Map of all the keys and values for all fields associated with this
 	 * object. The values are either the actual primitive values or the ID of the object
 	 * referenced, the Object is never retrieved.
 	 * 
 	 * @return
 	 */
 	public Map<FieldInfo,Object> getAllFieldsMap() {
 		Map<FieldInfo,Object> results = new HashMap<FieldInfo,Object>();
 		
 		FieldFilter allButShadowUserObject = new AllStoredFieldsFilter();
 		FieldIterator it = new FieldIterator(obj.getClass(),allButShadowUserObject);
 
 		for(Field f : it) {
 			FieldInfo key = new FieldInfo(f.getName(),f.getDeclaringClass(),FieldType.convert(f.getType()));
 			FieldKey fKey = new FieldKey(f.getDeclaringClass(),f.getName());
 			
 			FieldAccessor accessor = accessorFactory.create(fKey);
 			
 			Object value = accessor.getFieldRaw(fKey);
 			results.put(key, value);
 		}
 		return results;
 	}
 	
 	/**
 	 * Returns all JEMMObject fields that are uninitialised and their current value.
 	 * 
 	 * The value is either a valid ID or null if the field contains no mapping.
 	 * 
 	 * @return Mapping of Field information to ID or null if no mapping exists
 	 */
 	public Map<FieldKey,ID> getUninitialisedObjectFields() {
 		Map<FieldKey,ID> result = new HashMap<FieldKey,ID>();
 		
 		FieldFilter filter = new JEMMObjectFilter();
 		FieldIterator it = new FieldIterator(obj.getClass(),filter);
 		
 		for(Field f : it) {
 			Entity e = new Entity(obj);
 			if(!e.getShadowData().isFieldInitialised(f.getDeclaringClass(), FieldType.OBJECT, f.getName())) {
 				FieldKey fKey = new FieldKey(f.getDeclaringClass(),f.getName());
 				FieldAccessor accessor = accessorFactory.create(fKey);
 				result.put(fKey,(ID)accessor.getFieldRaw(fKey));
 			}
 		}
 		
 		return result;
 	}
 	
 	/**
 	 * Returns the objects referred to by JEMMObject fields that
 	 * are currently initialised.
 	 * 
 	 * @return Mapping of Field to JEMMObject or null if no mapping exists
 	 */
 	public Map<FieldKey,JEMMObject> getInitialisedObjectFields() {
 		Map<FieldKey,JEMMObject> result = new HashMap<FieldKey,JEMMObject>();
 		
 		FieldFilter filter = new JEMMObjectFilter();
 		FieldIterator it = new FieldIterator(obj.getClass(),filter);
 		
 		for(Field f : it) {
 			Entity e = new Entity(obj);
 			if(e.getShadowData().isFieldInitialised(f.getDeclaringClass(), FieldType.OBJECT, f.getName())) {
 				FieldKey fKey = new FieldKey(f.getDeclaringClass(),f.getName());
 				FieldAccessor accessor = accessorFactory.create(fKey);
 				result.put(fKey,(JEMMObject)accessor.getField(fKey));
 			}
 		}
 		
 		return result;
 	}
 }