package org.sourceforge.jemm.lifecycle;
   
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.Map;
   import java.util.Set;
   
   import org.sourceforge.jemm.database.FieldInfo;
   import org.sourceforge.jemm.database.FieldType;
  import org.sourceforge.jemm.types.ID;
  
  /**
   * The data store for the ShadowObject that is associated with an Enhanced
   * class.
   * 
   * Stores the ID of Shadowed Objects.
   * 
   * @author Paul Keeble
   * 
   */
  public class ShadowData {
  	ID id;
  	int version;
  	Map<FieldInfo, ID> fieldData;
  	Set<FieldInfo> initialisations;
  	
  	public ShadowData(ID id, int version) {
  		if (id == null)
  			throw new IllegalArgumentException("ID may not be null");
  		this.id = id;
  		this.version = version;
  	}
  
  	/**
  	 * Sets a field value.
  	 * 
  	 * @param type
  	 *            The type of the field
  	 * @param name
  	 *            The name of the field
  	 * @param value
  	 *            The value the field should take
  	 */
  	@SuppressWarnings("unchecked")
  	public void setField(Class declaringClass, FieldType type, String name, ID value) {
  		initialiseFieldData();
  		if(type==FieldType.OBJECT || type==FieldType.OBJECT_ARRAY) {
  			fieldData.put(new FieldInfo(name,declaringClass, type), value);
  		}
  	}
  	
  	/**
  	 * Allows lazy initialisation of the fieldData if its not needed for a
  	 * class, which could save a dramatic amount of RAM on large numbers of such
  	 * instances.
  	 */
  	private void initialiseFieldData() {
  		if (fieldData == null)
  			fieldData = new HashMap<FieldInfo, ID>();
  	}
  
  	/**
  	 * Returns a field if it exists, otherwise throws an exception
  	 * 
  	 * @param type
  	 *            The class type of the field
  	 * @param name
  	 *            The name of the field
  	 * @return The value stored, which can be null
  	 * @throws RuntimeException
  	 *             if the field does not exist
  	 */
  	@SuppressWarnings("unchecked")
  	public ID getField(Class declaringClass, FieldType type, String name) {
  		FieldInfo key = new FieldInfo(name,declaringClass,type);
  		
  		if (fieldData == null)
  			throw new RuntimeException("Field " + key + " does not exist");
  		
  		if (fieldData.containsKey(key))
  			return fieldData.get(key);
  		
  		throw new RuntimeException("Field " + key + " does not exist");
  	}
  	
  	/**
  	 * Returns an array of all the fields, which could be zero length if none
  	 * exist.
  	 * 
  	 * @return The fields contained within this ShadowData
  	 */
  	public FieldInfo[] getFields() {
  		if (fieldData == null)
  			return new FieldInfo[0];
  		return fieldData.keySet().toArray(new FieldInfo[0]);
  	}
  	
  	public boolean hasField(Class<?> declaringClass, FieldType type, String name) {
  		if(fieldData==null)
 			return false;
 		return fieldData.containsKey(new FieldInfo(name,declaringClass,type));
 	}
 	
 	/**
 	 * Gets the Object ID the ShadowData is associated with.
 	 * 
 	 * @return The ID
 	 */
 	public ID getID() {
 		return id;
 	}
 
 	/**
 	 * The version of the Object has defined by the Database that gave the ID to
 	 * the enhanced object.
 	 * 
 	 * @return The version id.
 	 */
 	public int getVersion() {
 		return version;
 	}
 
 	/**
 	 * Sets the version to a new value.
 	 * 
 	 * @param newVersion
 	 *            The new version parameter.
 	 */
 	public void setVersion(int newVersion) {
 		version = newVersion;
 	}
 	
 	private void initialiseMapSetup() {
 		if(initialisations==null)
 			initialisations = new HashSet<FieldInfo>();
 	}
 	
 	/**
 	 * Sets the status of a Field to say that it has already been initialised to the
 	 * Entity.
 	 * 
 	 * @param declaringClass
 	 * @param type
 	 * @param name
 	 */
 	public void initialiseField(Class<?> declaringClass, FieldType type, String name) {
 		if(!hasField(declaringClass,type,name)) 
 			return;
 		initialiseMapSetup();
 		initialisations.add(new FieldInfo(name,declaringClass,type));
 	}
 	
 	/**
 	 * Removes the initialisation flag for a field.
 	 * 
 	 * @param declaringClass
 	 * @param type
 	 * @param name
 	 */
 	public void clearInitialisation(Class<?> declaringClass, FieldType type, String name) {
 		if(initialisations==null)
 			return;
 		initialisations.remove(new FieldInfo(name,declaringClass, type));
 	}
 	
 	public void clearInitialisations() {
 		if(initialisations==null)
 			return;
 		initialisations = null;
 	}
 	
 	/**
 	 * Returns the current known initialisation state of an Object.
 	 * 
 	 * @param declaringClass
 	 * @param type
 	 * @param name
 	 * @return True if the object is currently initialised, otherwise false.
 	 */
 	public boolean isFieldInitialised(Class<?> declaringClass, FieldType type, String name) {
 		FieldInfo key = new FieldInfo(name,declaringClass,type);
 		if(initialisations!=null && initialisations.contains(key)) {
 			return true;
 		}
 		return false;
 	}
 	
 	public String toString() {
 		StringBuilder builder = new StringBuilder("ShadowData[");
 		for(FieldInfo fi : fieldData.keySet()) {
 			builder.append(fi);
 			builder.append("=");
 			builder.append(fieldData.get(fi));
 			if(initialisations.contains(fi))
 				builder.append("*");
 			builder.append(",");
 		}
 		builder.append("]");
 		return builder.toString();
 	}
 
 }