package org.sourceforge.jemm.client;
   
   import org.sourceforge.jemm.JEMMInternalException;
   import org.sourceforge.jemm.client.events.LockTracer;
   import org.sourceforge.jemm.client.events.StackTracer;
   import org.sourceforge.jemm.lifecycle.ConstructorListener;
   import org.sourceforge.jemm.lifecycle.LifecycleEvent;
   import org.sourceforge.jemm.lifecycle.LockEvent;
   import org.sourceforge.jemm.lifecycle.MethodEvent;
  import org.sourceforge.jemm.lifecycle.MethodListener;
  import org.sourceforge.jemm.lifecycle.TypeConstructorListener;
  import org.sourceforge.jemm.util.ConstructorContext;
  import org.sourceforge.jemm.util.ContextStack;
  import org.sourceforge.jemm.util.JEMMObject;
  import org.sourceforge.jemm.util.JEMMType;
  
  /**
   * A lifecycle listener which manages the state of the JEMMObject, such as the
   * object values, the JEMM ID and the ShadowObject.
   * 
   * <pre> 
  Hierarchy of class constructors
  -------------------------------
  
  pre - stack the class
  super -> 
  	pre - stack the class
  	super
  	begin - associated the the object with stacked class
  
  	end/fail
  begin
  end/fail
  ---
  END/FAIL ALGORITHM
  pop
  if(peek is a class in the hierarchy of current OBJ AND has no object)
  	do nothing
  else //must be a different object on the stack
  	synchronize
  ---
  
  
  Nested Construction of objects
  ------------------------------
  
  pre
  super
  begin
  	pre
  	begin
  	end/fail
  end/fail
  </pre>
   * 
   * @author Paul Keeble
   * 
   */
  public class LifecycleListenerImpl implements ConstructorListener,
  		MethodListener,TypeConstructorListener {
  
  	ObjectDatabase db;
  	ObjectDatabase whenLockedDB;
  
  	private JEMMObjectCreator objectCreator;
  	private StackTracer stackTracer;
  	private LockTracer lockTracer;
  	
  	public LifecycleListenerImpl(ObjectDatabase db,StackTracer st, LockTracer lt) {
  		this.db = db;
  		this.whenLockedDB = new AlwaysRefreshObjectDatabase(db);
  		
  		this.stackTracer = st;
  		this.lockTracer = lt;
  	}
  
  	/**
  	 * 
  	 */
  	@Override
  	public void preConstructor(String className) {
  		ContextStack.pushReference(new ConstructorContext(className));
  	}
  	
  	/**
  	 * Register the class of the object.
  	 * 
  	 * Gets the ID for a new object and sets it back to the original object
  	 * along with the ShadowObject.
  	 * 
  	 * If the constructor for the same object but a super class is called this should
  	 * be ignored and no further registrations or IDs retrieved.
  	 */
  	@Override
  	public void beginConstructor(LifecycleEvent e) {
  		JEMMObject origin = e.getOrigin();
  		
  		ConstructorContext cc = (ConstructorContext)ContextStack.peekReference();
  		cc.associateObject(origin);
 		
 		objectCreator.initialise(origin);
 	}
 
 	public void setObjectCreator(JEMMObjectCreator creator) {
 		this.objectCreator = creator;
 	}
 	
 	@Override public void typeConstructed(JEMMType typeInstance) {
 
 		objectCreator.initialise(typeInstance);
     }
 	
 	/**
 	 * Removes the context for the constructor from the stack.
 	 */
 	@Override
 	public void failedConstruction(LifecycleEvent e) {
 		ContextStack.popReference();
 	}
 
 	/**
 	 * Synchronise the state of the Object with the database and clear any
 	 * object fields of their values into the ShadowData. The fields should only
 	 * be saved/cleared if the Object is being exited and hence this is the last
 	 * endConstructor being called for this Objects creation.
 	 */
 	@Override
 	public void endConstructor(LifecycleEvent e) {
 		ConstructorContext context = (ConstructorContext)ContextStack.popReference();
 		ConstructorContext peekedContext = (ConstructorContext)ContextStack.peekReference();
 
 		JEMMObject origin = e.getOrigin();
 		if(context==null || context.getObject()!=origin)
 			throw new JEMMInternalException("ContextStack corrupted");
 		
 		if(peekedContext!=null && !peekedContext.hasObject() && isParent(context.getClazz(),peekedContext.getClazz())) {
 			//this is a parent call super class constructor call, we don't need to synchronize
 			return;
 		}
 		
 		ObjectAccessor oa = new ObjectAccessor(origin,db);
 		oa.finaliseAllFields();
 		db.synchroniseObject(origin);
 	}
 	
 	private boolean isParent(String parent,String child) {
 		try {
 			Class<?> parentClass = Class.forName(parent);
 			Class<?> childClass = Class.forName(child);
 			return childClass.getSuperclass().equals(parentClass);
 		} catch (ClassNotFoundException e) {
 			throw new JEMMInternalException("Unable to convert to class " + e.getMessage());
 		}
 	}
 
 	/**
 	 * Acquire a lock in the database
 	 */
 	@Override
 	public void beginLock(LockEvent e) {
 		lockTracer.beginLock(e.getOrigin(), e.getLock());
 	}
 
 	/**
 	 * Release a lock in the database
 	 */
 	@Override
 	public void endLock(LockEvent e) {
 		lockTracer.endLock(e.getOrigin(), e.getLock());
 	}
 
 	/**
 	 * Register the class
 	 * 
 	 * Setup the required object fields that will be used by the method if it is
 	 * the first time a method is entered. If an attribute has already been
 	 * setup then the value (even if it has changed) is left in place.
 	 * 
 	 * Track the call stack to allow the exit method to determine if it can save
 	 * the values.
 	 */
 	@Override
 	public void entityEntered(MethodEvent e) {
 		stackTracer.enterMethod(e.getOrigin(), new Descriptor(e.getDescriptor()));
 	}
 
 	/**
 	 * Captures the object state and saves it.
 	 * 
 	 * This is only done if the Object is actually being exited by this call, if
 	 * it is not then the fields should be left in tact and no storage of
 	 * attributes done until this is called the last time for a method entry.
 	 * 
 	 * Release all the JEMMObject fields that were initialised by entityEntered
 	 */
 	@Override
 	public void entityExited(MethodEvent e) {
 		stackTracer.exitMethod(e.getOrigin(), new Descriptor(e.getDescriptor()));
 	}
 
 }