package org.sourceforge.jemm.client;
   
   import java.util.Map.Entry;
   
   import org.sourceforge.jemm.client.shared.Encodable;
   import org.sourceforge.jemm.client.shared.ValueEncoder;
   import org.sourceforge.jemm.database.ClassId;
   import org.sourceforge.jemm.database.ClassInfo;
   import org.sourceforge.jemm.database.ClientId;
  import org.sourceforge.jemm.database.ClientThreadId;
  import org.sourceforge.jemm.database.Database;
  import org.sourceforge.jemm.database.EnumId;
  import org.sourceforge.jemm.database.EnumInfo;
  import org.sourceforge.jemm.database.FieldInfo;
  import org.sourceforge.jemm.database.FieldType;
  import org.sourceforge.jemm.database.GetObjectResp;
  import org.sourceforge.jemm.database.LockAcquiredListener;
  import org.sourceforge.jemm.database.ObjectSyncData;
  import org.sourceforge.jemm.database.ObjectSyncResp;
  import org.sourceforge.jemm.database.StructureModifiedException;
  import org.sourceforge.jemm.lifecycle.TypeRequest;
  import org.sourceforge.jemm.lifecycle.TypeResponse;
  import org.sourceforge.jemm.types.ID;
  import org.sourceforge.jemm.util.JEMMObject;
  
  /**
   * An Adapter that maps the ObjectState fields onto actual objects, which
   * are created and stores the objects it creates into a memory sensitive
   * cache.
   * 
   * When objects are garbage collected the reference is cleared. Otherwise
   * requests for objects with an id already pulled will return the exact same object.
   * 
   * 
   * @author Paul Keeble
   *
   */
  public class DatabaseAdapter implements ObjectDatabase {
  	protected final ClientId clientId = new ClientId("CLIENT");
  
  	protected final Database database;
  	protected JEMMObjectFactory objectFactory;
  	
  	protected JEMMObjectCreator objectCreator;
  	
  
  	public DatabaseAdapter(final Database database,JEMMObjectCreator creator) {
  		this.database = database;
  		this.objectCreator = creator;
  		
  		if(objectCreator == null)
  			objectCreator = new JEMMObjectCreatorImpl(null,this);
  		
  		objectFactory = new JEMMObjectFactory() {
  
  			@Override
  			protected JEMMObject createValue(ID id) {
  				GetObjectResp resp = database.getObject(clientId,id);
  				ClassInfo ci = database.getClassInfo(clientId,resp.getClassId());
  				return objectCreator.createObject(resp,ci);
  			}			
  		};
  	}
  	
  	public DatabaseAdapter(Database database) {
  		this(database,null);
  	}
  
  	public void setObjectCreator(JEMMObjectCreator creator) {
  		this.objectCreator = creator;
  	}
  
  	/**
  	 * Looks up the Object with ID jemmId and converts from the underlying
  	 * Delegate database into the actual JEMMObject from the response data.
  	 * 
  	 * This  routine:
  	 * - Converts any IDs to trackedIDs
  	 * - Creates the object based on the known class information
  	 * - Sets up the ShadowObject
  	 * - Sets up the fields on the object/ShadowData 
  	 * - caches the resulting objects mapped by ID
  	 */
  	@Override
  	public JEMMObject getObject(ID jemmId) {		
  		return objectFactory.create(jemmId);
  	}
  	
  	public JEMMObject getRefreshedObject(ID jemmId) {
  		if(objectFactory.contains(jemmId)) {
  			JEMMObject obj = objectFactory.create(jemmId);
  			refreshObject(obj);
  			return obj;
  		}
  		return getObject(jemmId);
  	}
  	
  	/**
  	 * Refreshes an objects state by:
 	 * - Retrieving the object again from the database and setting all primitives to the new values
 	 * - setting all uninitialised Object fields to the new values
 	 * - For initialised fields that are objects either:
 	 *   *) Matches the ID return from step 1 and refresh the object recursively
 	 *   *) Does not match the ID, the new object is retrieved and set as the value.
 	 */
 	public void refreshObject(JEMMObject obj) {
 		Entity mainObjectEntity = new Entity(obj);
 		ObjectAccessor oa = new ObjectAccessor(obj,null);
 		GetObjectResp response = database.getObject(clientId,mainObjectEntity.getID());
 		objectCreator.refreshPrimitiveState(obj, response);		
 		refreshInitialisedFields(oa,response);
 	}
 	
 	private void refreshInitialisedFields(ObjectAccessor oa, GetObjectResp response) {
 		for(Entry<FieldKey,JEMMObject> entry : oa.getInitialisedObjectFields().entrySet()) {
 			
 			ID objID = (entry.getValue()==null) ? null : new Entity(entry.getValue()).getID();
 			FieldKey fKey = entry.getKey();
 			FieldInfo fi = new FieldInfo(fKey.getName(),fKey.getClazz(),FieldType.OBJECT);
 			
 			ID refreshValue = (ID)response.fieldValues.get(fi);
 			
 			if(refreshValue==null && objID == null) {
 				continue;
 			} else if(refreshValue == null && objID!=null) {
 				oa.setField(fKey.getClazz(), fKey.getName(), null);
 			} else if(refreshValue.equals(objID)) {
 				refreshObject(entry.getValue());
 			} else {
 				JEMMObject newValue = getRefreshedObject(refreshValue);
 				oa.setField(fKey.getClazz(), fKey.getName(), newValue);
 			}
 		}
 	}
 
 	/**
 	 * Takes all the data from the syncData object and creates an ObjectSyncData
 	 * packet which is then passed to the delegated Database.
 	 * @param syncData the JEMMObject data to use.
 	 * 
 	 */
 	@Override
 	public void synchroniseObject(JEMMObject jo) {
 		
 		ObjectSyncData syncData = objectCreator.getSyncData(jo);
 
 		ObjectSyncResp response = database.synchroniseObject(clientId, syncData.jemmId, syncData);
 		objectCreator.syncResponseUpdateObject(jo, response);
 	}
 	
 	@Override
 	public void setRoot(String rootName, JEMMObject newValue) {
 		if(newValue == null)
 			database.setRoot(clientId,rootName, null);
 		else {
 			ID id = new Entity(newValue).getID();
 			database.setRoot(clientId,rootName, id);			
 		}		
 	}
 
 	@Override
 	public JEMMObject setRootIfNull(String rootName, JEMMObject newValue) {
 		if(newValue == null)
 			throw new NullPointerException("New value cannot be null");
 		ID newId = new Entity(newValue).getID();		
 		ID postSetValueId =  database.setRootIfNull(clientId,rootName, newId);
 		return getObject(postSetValueId);
 	}
 	
 	@Override
 	public JEMMObject getRoot(String rootName) {
 		ID rootID = database.getRoot(clientId,rootName);
 		if(rootID==null)
 			return null;
 		else
 			return getObject(rootID);
 	}
 	
 	public int cacheSize() {
 		return objectFactory.size();
 	}
 
 	@Override
 	public void acquireLock(ClientThreadId threadId, ID jemmId) {
 		database.acquireLock(threadId, jemmId);
 	}
 
 	@Override
 	public void setClientLockAcquiredListener(ClientId clientId,
 			LockAcquiredListener listener) {
 		database.setClientLockAcquiredListener(clientId, listener);
 	}
 
 	@Override
 	public ClassInfo getClassInfo(ClassId classId) {
 		return database.getClassInfo(clientId,classId);
 	}
 
 	@Override
 	public EnumInfo getEnumInfo(EnumId enumId) {
 		return database.getEnumInfo(clientId,enumId);
 	}
 
 	@Override
 	public ID newObject(ClassId classId,JEMMObject target) {
 		ID id = database.newObject(clientId,classId);
 		objectFactory.put(id,target);
 		return id;
 	}
 
 	@Override
 	public ClassId registerClass(ClassInfo classInfo) throws StructureModifiedException {	    
 		return database.registerClass(clientId,classInfo);
 	}
 
 	@Override
 	public EnumId registerEnum(EnumInfo enumInfo) throws StructureModifiedException {
 		return database.registerEnum(clientId,enumInfo);
 	}
 
 	@Override
 	public void releaseLock(ClientThreadId threadId, ID jemmId) {
 		database.releaseLock(threadId, jemmId);
 	}
 
 	@Override
 	public void removeLockAcquiredListener(ClientId clientId) {
 		database.removeLockAcquiredListener(clientId);
 	}
 	
 	abstract class FieldValueEncoder extends ValueEncoder {
 		@SuppressWarnings("unchecked")
 		@Override public <K> K encode(K value) {
 			if(value == null)
 				return value;
 			if(value instanceof Encodable) {
 				return (K) ((Encodable) value).encode(this);
 			} 
 			
 			if(value instanceof Object[]) {
 				Object[] arr = ((Object[]) value).clone();
 				for(int i=0; i<arr.length; i++)
 					arr[i] = encode(arr[i]);
 				return (K) arr;
 			}
 
 			return encodeSingle(value);
 		}
 
 		public abstract <K> K encodeSingle(K value);
 	}
 	
 	ValueEncoder toIdEncoder = new FieldValueEncoder() {
 		@SuppressWarnings("unchecked")
 		@Override public <K> K encodeSingle(K value) {
 			if(value instanceof JEMMObject)
 				return (K) (new Entity((JEMMObject) value)).getID();				
 			else
 				return value;
 		}
 	};
 
 	ValueEncoder toObjectEncoder = new FieldValueEncoder() {
 		@SuppressWarnings("unchecked")
 		@Override public <K> K encodeSingle(K value) {
 			if(value instanceof ID)
 				return (K) getObject((ID) value);
 			else
 				return value;
 		}
 	};
 	
 	@Override
 	public TypeResponse<?> processTypeRequest(JEMMObject obj,ClassId classId,TypeRequest<?> request) {
 		
 		ID objId = new Entity(obj).getID();		
 		TypeRequest<?> encodedRequest = toIdEncoder.encode(request);
 		TypeResponse<?> encodedResp = database.processTypeRequest(clientId, classId, 
 				objId,encodedRequest);
 		
 		return toObjectEncoder.encode(encodedResp);
 	}
 	
 	public void shutdown() {
 		objectFactory.shutdown();
 	}
 }