package org.sourceforge.jemm.client;
   
   import java.util.ArrayList;
   import java.util.Arrays;
   import java.util.Collections;
   import java.util.HashMap;
   import java.util.HashSet;
   import java.util.List;
   import java.util.Map;
  import java.util.Map.Entry;
  import java.util.Set;
  import java.util.concurrent.locks.Lock;
  import java.util.concurrent.locks.ReadWriteLock;
  import java.util.concurrent.locks.ReentrantReadWriteLock;
  
  import org.sourceforge.jemm.client.id.TrackedID;
  import org.sourceforge.jemm.client.id.TrackedIDFactory;
  import org.sourceforge.jemm.client.id.TrackedIDListener;
  import org.sourceforge.jemm.client.shared.ValueEncoder;
  import org.sourceforge.jemm.database.ClassId;
  import org.sourceforge.jemm.database.ClientId;
  import org.sourceforge.jemm.database.ClientThreadId;
  import org.sourceforge.jemm.database.Database;
  import org.sourceforge.jemm.database.FieldInfo;
  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.lifecycle.TypeRequest;
  import org.sourceforge.jemm.lifecycle.TypeResponse;
  import org.sourceforge.jemm.types.ID;
  
  /**
   * This Database implementation tracks maps any ids from the delegated database into
   * singleton tracked ids (i.e. for any given object, there will be one singleton instance 
   * of a tracked id.  All down calls to the delegate will have the tracked ids mapped back to 
   * regular ids. 
   * <P> It is responsible for detecting live use of the ids within the client code, once a client
   * has finished using a tracked id, it will be garbage collected and the database will inform the
   * underlying database that the id is no longer referenced.
   * <P> To avoid a race condition between marking an id as unused and it being passed back in 
   * another call, the database users locking
   * <P> <B> N.b. </B> This is heavily based upon the original ReferenceCleaner implementation and
   * effectively is moving that code down into the Database rather than ObjectDatabase layer.
   * 
   * @author Paul Keeble
   * @author Rory Graves
   */
  public class TrackingDatabase extends DelegatingDatabase {
  	/** Sleep time between reference cleaning cycles (in ms) */
  	public static final long SLEEP_TIME=10;
  
  	private Set<ID> queued;
  	private Thread clearingThread;
  	
  	private final ClientId refClearedClientId = new ClientId("CLIENT");
  
  	private final TrackedIDFactory trackedIDFactory;
  	
  	/** Handlers for listener */
  	private ClientId callerListenerClientId;
  	private LockAcquiredListener callerLockListener;
  	
  	private final ReadWriteLock lock;
  	private final Lock updateLock;
  	private final Lock gcLock;
  
  	private final WrappingMapper wrappingMapper = new WrappingMapper();
  	private final UnwrappingMapper unwrappingMapper = new UnwrappingMapper();
  	
  	public TrackingDatabase(Database delegate,TrackedIDFactory idFactory) {
  		super(delegate);
  		lock = new ReentrantReadWriteLock();
  		updateLock = lock.readLock();
  		gcLock = lock.writeLock();
  		queued = Collections.synchronizedSet(new HashSet<ID>());
  
  		this.trackedIDFactory = idFactory;
  		trackedIDFactory.addListener(new TrackedIDListener() {
  			@Override
  			public void expired(ID id) {
  				queued.add(id);
  			}			
  		});
  		
  		clearingThread = new Thread(new QueueReader(),"Reference Cleaner");
  		clearingThread.setDaemon(true);
  		clearingThread.start();
  	}
  	
  	private ID unwrapId(ID wrappedId) {
  		
  		if(wrappedId == null)
  			return null;
  		
  		// unwrap an id for passing down
  		if(wrappedId instanceof TrackedID) 
  			return new ID(wrappedId.getIDValue());
  		else
 			// no raw ids should have been passed in by the layer above
 			throw new IllegalStateException("All ids passed in must be TrackedIDs");
 	}
 
 	/**
 	 * Wrap an id as a TrackedID for passing up to higher levels.
 	 * @param unwrappedId The id to wrap.
 	 * @return
 	 */
 	private ID wrapId(ID unwrappedId) {
 		if(unwrappedId == null)
 			return null;
 		else if(unwrappedId instanceof TrackedID)
 			throw new IllegalStateException("TrackedID should not occur in lower levels");
 		else
 			return trackedIDFactory.create(unwrappedId);
 	}
 	
 	private class WrappingMapper extends ValueEncoder implements ValueMapper {
 
 		@Override public ID mapID(ID id) {
 			return wrapId((ID) id);
 		}
 
 		@Override public Object map(Object o) {
 			if(o instanceof ID)
 				return wrapId((ID) o);
 			else
 				return o;
 		}
 
 		@SuppressWarnings("unchecked")
 		@Override
 		public <K> K encode(K value) {
 			if(value instanceof ID)
 				return (K) wrapId((ID) value);
 			else
 				return value;
 		}
 	}
 
 	private class UnwrappingMapper extends ValueEncoder implements ValueMapper {
 
 		@Override public ID mapID(ID id) {
 			return unwrapId((ID) id);
 		}
 		@Override public Object map(Object o) {
 			if(o instanceof ID)
 				return unwrapId((ID) o);
 			else
 				return o;
 		}
 		
 		@SuppressWarnings("unchecked")
 		@Override public <K> K encode(K value) {
 			if(value instanceof ID)
 				return (K) unwrapId((ID) value);
 			else
 				return value;
 		}
 	}
 
 	@Override public void acquireLock(ClientThreadId threadId, ID jemmId) {
 		super.acquireLock(threadId, unwrapId(jemmId));
 	}
 	
 	@Override public GetObjectResp getObject(ClientId clientId, ID jemmId) {
 		try {
 			updateLock.lock();
 			GetObjectResp resp = super.getObject(clientId, unwrapId(jemmId));
 			return mapGetObjResp(resp,wrappingMapper);
 		} finally {
 			updateLock.unlock();
 		}		
 	}
 	@Override public ID getRoot(ClientId clientId, String rootName) {
 		try {
 			updateLock.lock();
 			return wrapId(super.getRoot(clientId, rootName));
 		} finally {
 			updateLock.unlock();
 		}		
 	}
 	@Override public ID newObject(ClientId clientId, ClassId classId) {
 		return wrapId(super.newObject(clientId, classId));
 	}
 	@Override public void referenceCleared(ClientId clientId, ID... ids) {
 		throw new IllegalStateException("Higher level database should not call this method");
 	}	
 	@Override public void releaseLock(ClientThreadId threadId, ID jemmId) {
 		super.releaseLock(threadId, unwrapId(jemmId));
 	}
 	@Override public void setRoot(ClientId clientId, String rootName, ID newValue) {
 		super.setRoot(clientId, rootName, unwrapId(newValue));
 	}
 	@Override public ID setRootIfNull(ClientId clientId, String rootName, ID newValue) {
 		try {
 			updateLock.lock();
 			return wrapId(super.setRootIfNull(clientId, rootName, unwrapId(newValue)));
 		} finally {
 			updateLock.unlock();
 		}		
 	}
 	@Override public ObjectSyncResp synchroniseObject(ClientId clientId, ID jemmId,
 			ObjectSyncData syncData) {
 		try {
 			updateLock.lock();
 			// wrap the request fields
 			ObjectSyncData toSendSyncData = mapSyncData(syncData,unwrappingMapper);
 			ObjectSyncResp resp = super.synchroniseObject(clientId, unwrapId(jemmId), toSendSyncData);
 			return mapSyncRespData(resp,wrappingMapper);
 		} finally {
 			updateLock.unlock();
 		}		
 	}
 	@Override public TypeResponse<?> processTypeRequest(ClientId clientId,
 			ClassId classId, ID objId, TypeRequest<?> request) {
 		try {
 			updateLock.lock();
 			TypeRequest<?> toSendRequest = (TypeRequest<?>) request.encode(unwrappingMapper);
 			TypeResponse<?> resp = super.processTypeRequest(clientId, classId, unwrapId(objId), toSendRequest);
 			return (TypeResponse<?>) resp.encode(wrappingMapper);
 		} finally {
 			updateLock.unlock();
 		}
 	}
 
 	@Override public synchronized void removeLockAcquiredListener(ClientId clientId) {
 		super.removeLockAcquiredListener(clientId);
 		callerListenerClientId = null;
 		callerLockListener = null;
 	}
 	@Override public synchronized void setClientLockAcquiredListener(ClientId clientId,
 			LockAcquiredListener listener) {
 		if(this.callerListenerClientId != null)
 			throw new IllegalStateException("client lock acquire listener already set");
 	
 		this.callerListenerClientId = clientId;
 		this.callerLockListener = listener;
 		super.setClientLockAcquiredListener(clientId, new LockAcquiredListener() {
 
 			@Override
 			public void lockAcquired(ClientThreadId threadId, ID objectId) {
 				callerLockListener.lockAcquired(threadId, wrapId(objectId));
 			}
 			
 		});
 	}
 
 	// methods to create new instances of the requests with all of the fields
 	// mapped. 
 	
 	private GetObjectResp mapGetObjResp(GetObjectResp src, ValueMapper mapper) {
 		
 		return new GetObjectResp(mapper.mapID(src.jemmId),src.getClassId(),src.clientVersion,
 				mapFieldValues(src.fieldValues,mapper));
 	}
 
 	private Map<FieldInfo, Object> mapFieldValues(Map<FieldInfo, Object> src,ValueMapper mapper) {
 		Map<FieldInfo,Object> newFields = new HashMap<FieldInfo, Object>();
 		for (Entry<FieldInfo, Object> srcField : src.entrySet())
 			newFields.put(srcField.getKey(), mapper.map(srcField.getValue()));
 		
 		return newFields;
 	}
 
 	private ObjectSyncResp mapSyncRespData(ObjectSyncResp resp, ValueMapper mapper) {
 		return new ObjectSyncResp(resp.getNewVersionNo(),
 				mapFieldValues(resp.getUpdatedFields(), mapper));
 	}
 
 	private ObjectSyncData mapSyncData(ObjectSyncData syncData,ValueMapper mapper) {
 		return new ObjectSyncData(mapper.mapID(syncData.jemmId),
 				syncData.clientVersion,mapFieldValues(syncData.fieldValues, mapper));
 	}
 	
 	/**
 	 * An implementation that watches for elements in the
 	 * queue and takes a batch of IDs and passes them down
 	 * the stack if they are no longer tracked.
 	 * 
 	 * @author Paul Keeble
 	 *
 	 */
 	class QueueReader implements Runnable {
 		public void run() {
 			try {
 				while(true) {
 					if(queued.size()==0) {
 						Thread.sleep(SLEEP_TIME);
 					} else {
 						acquireLockAndClear();
 					}
 				}
 			} catch (InterruptedException e) {
 				// do nothing
 			}
 		}
 		
 		public void acquireLockAndClear() {
 			try {
 				gcLock.lock();
 				ID[] candidates = queued.toArray(new ID[0]);
 				ID[] toClear = removeCurrentlyTracked(candidates);
 				if(toClear.length>0)
 					internalClearRererence(toClear);
 				
 				queued.removeAll(Arrays.asList(candidates));
 			} finally {
 				gcLock.unlock();
 			}
 		}
 		
 		public ID[] removeCurrentlyTracked(ID[] candidateIds) {
 			List<ID> toClearIds = new ArrayList<ID>();
 			for(ID id : candidateIds) {
 				if(!trackedIDFactory.contains(id))
 					toClearIds.add(id);
 			}
 			
 			return toClearIds.toArray(new ID[0]);
 		}		
 	}
 	
 	public void internalClearRererence(ID[] toClear) {
 		super.referenceCleared(refClearedClientId, toClear);
 	}
 	
 	/**
 	 * TrackingDatabase uses a separate thread to pass ID information for cleaning,
 	 * shutdown must be called to recover that native resource to avoid leaks.
 	 * 
 	 */
 	public void shutdown() {
 		clearingThread.interrupt();
 	}
 }