/**
    * 
    */
   package org.sourceforge.jemm.database.components;
   
   import java.util.HashMap;
   import java.util.Iterator;
   import java.util.Map;
   import java.util.Set;
  
  import org.sourceforge.jemm.database.ClassId;
  import org.sourceforge.jemm.database.ClassInfo;
  import org.sourceforge.jemm.database.ClientId;
  import org.sourceforge.jemm.database.ObjectAccessor;
  import org.sourceforge.jemm.database.ObjectSyncData;
  import org.sourceforge.jemm.database.ObjectSyncResp;
  import org.sourceforge.jemm.database.components.interfaces.DBClassHandler;
  import org.sourceforge.jemm.database.components.interfaces.DBClientRefHandler;
  import org.sourceforge.jemm.database.components.interfaces.DBObjectHandler;
  import org.sourceforge.jemm.database.components.se.StorageEngineObjectIF;
  import org.sourceforge.jemm.database.components.types.StoredListObject;
  import org.sourceforge.jemm.database.components.types.StoredMapObject;
  import org.sourceforge.jemm.database.components.types.StoredObject;
  import org.sourceforge.jemm.database.components.types.StoredSetObject;
  import org.sourceforge.jemm.database.components.types.StoredUserObject;
  import org.sourceforge.jemm.types.ID;
  import org.sourceforge.jemm.util.LockManager;
  
  /**
   * Default implementation of DBObjectHandler used by BaseDatabase based implementations.
   * @author Rory Graves
   */
  public class DefaultDBObjectHandler implements DBObjectHandler,ObjectAccessor {
  	private final StorageEngineObjectIF seObjectIF;
  	private final LockManager<ID> lockManager;
  	private final DBClassHandler classHandler;
  	private final DBClientRefHandler clientRefHandler;
  
  	private ObjectStatusListener objectStatusListener;
  	private Map<ClassId,TypeHandler> typeHandlers = new HashMap<ClassId, TypeHandler>();
  	
  	/** Creates a DefaultDBObjectHandler instance with the given parameters.
  	 * @param storageEngine The underlying storage engine.
  	 * @param classHandler The class handler to use.
  	 * @param clientRefHandler The client reference handler to use.
  	 */
      public DefaultDBObjectHandler(StorageEngine storageEngine,DBClassHandler classHandler,
      		DBClientRefHandler clientRefHandler) {
      	this.seObjectIF = storageEngine.getObjectIF();
      	this.lockManager = new LockManager<ID>();
      	this.classHandler = classHandler;
      	this.clientRefHandler = clientRefHandler;
      }
      
      public void setObjectStatusListener(ObjectStatusListener objectStatusListener) {
      	this.objectStatusListener = objectStatusListener;
      }
      
      public StoredObject getObject(ID objectId) {
      	lockManager.acquire(objectId);
  		
  		StoredObject object =  seObjectIF.getObject(objectId);
          if(object == null)
              throw new IllegalStateException("Object " + objectId + " missing");
  
  		if(object.getModified())
  			System.out.println("WARNING: ObjectStore.get on unsaved object " + objectId);
  		
  		return object;		
      }
  	
  	public void update(StoredObject object) {
  		object.clearModified();
  	}
      
      /**
       * Returns the stored user object referred to by 'id'
       * @param objectId The id of the object to retrieve.
       * @throws IllegalArgumentException If 'id' is null or is not UOBJECT type id.
       * @throws IllegalStateException If the object is not in the database (an internal error), or the type
       *         of the retrieved object is not a user object.
       */
      public StoredUserObject getUserObject(ID objectId) {
      	StoredObject so = getObject(objectId);
      	if(!(so instanceof StoredUserObject))
      		throw new IllegalArgumentException("Requested id " + objectId 
      				+ " not a user type object");
      	   
          return (StoredUserObject) so;
      }
  
      @Override
      public StoredListObject getListObject(ID objectId) {
      	StoredObject so = getObject(objectId);
      	if(!(so instanceof StoredListObject))
      		throw new IllegalArgumentException("Requested id " + objectId 
      				+ " not a jemm list type object");
      	   	
          return (StoredListObject) so;
     }
 
     @Override
     public StoredSetObject getSetObject(ID objectId) {
     	StoredObject so = getObject(objectId);
     	if(!(so instanceof StoredSetObject))
     		throw new IllegalArgumentException("Requested id " + objectId + " not a jemm set type object");
     	   	
         return (StoredSetObject) so;
     }
 
     @Override
     public StoredMapObject getMapObject(ID objectId) {
     	StoredObject so = getObject(objectId);
     	if(!(so instanceof StoredMapObject))
     		throw new IllegalArgumentException("Requested id " + objectId + " not a jemm map type object");
     	   	
         return (StoredMapObject) so;
     }
 
     /**
      * Creates a new user object with the given class type. <P>
      * <B>N.b.</B> Once initialisation is complete - caller should call objectAccessor.initialisationFinished on the 
      * returned id.
      * @param classId The classId of the new object.
      * @return The id of the newly created object.
      */
     public ID createObject(ClientId clientId,ClassId classId) {
         ID id = seObjectIF.generateId();
         StoredObject so;
         if(typeHandlers.containsKey(classId)) { 
         	// its a managed type
         	TypeHandler th = typeHandlers.get(classId);
         	so = th.createStorageObject(id);
         	
         } else { 
         	// its a user object
         	ClassInfo classInfo = classHandler.get(classId);
             so = new StoredUserObject(id,classId,classInfo);
         }
         	
         seObjectIF.save(so);
         objectStatusListener.objectCreated(id);
         clientRefHandler.recordReference(clientId, id);
         objectStatusListener.initialisationComplete(id);
 
         return id;
     }
 
     /**
      * @param objectId The id of the object being synchronized
      * @param syncData The synchronisation data, containing updated fields and current client version. 
      * @return The synchronized object response data.
      */
     public ObjectSyncResp synchroniseObject(ID objectId, ObjectSyncData syncData) {
 		StoredUserObject so = getUserObject(objectId);
     	try {    	
     		return so.synchronizeObject(syncData);
     	} finally {
     		release(so);
     	}
     }
 
     public void removeObject(ID id) {
     	seObjectIF.removeObject(id);
     }
 
     /**
      * @return The number of objects held in this database.
      */
     public int getObjectCount() {
     	return seObjectIF.count();
     }
 
 	@Override
 	public boolean checkExists(ID objectId) {
 		return seObjectIF.checkObjectExists(objectId);
 	}
 
 	@Override
 	public void release(StoredObject object) {
 		Thread currentThread = Thread.currentThread();
 		if(currentThread != lockManager.getLockHolder(object.getObjectId()))
 			throw new IllegalStateException("Current thread does not hold lock on " + object.getObjectId());
 		
 		if(object.getModified())
 			saveObject(object);
 		
 		lockManager.release(object.getObjectId());
 	}
 	
 	protected void saveObject(StoredObject object) {
 		seObjectIF.updateObject(object);
 	}
 
 	public int getNoLocksHeld() {
 		return lockManager.noLocksHeld();
 	}
 
 	@Override
 	public Iterator<ID> idIterator() {
 		return seObjectIF.idIterator();
 	}
 
 	@Override
 	public Set<ID> getObjectChildren(ID id) {
     	StoredObject so = getObject(id);
     	Set<ID> children = so.getReferencedObjects();
     	release(so);
     	return children;
 	}
 
 	@Override 
 	public void registerType(ClassId classId, TypeHandler handler) {
 		typeHandlers.put(classId, handler);
 	}
 }