/**
    * 
    */
   package org.sourceforge.jemm.database.components;
   
   import java.util.Iterator;
   import java.util.Set;
   import java.util.concurrent.CountDownLatch;
   import java.util.concurrent.TimeUnit;
  
  import org.apache.log4j.Logger;
  import org.sourceforge.jemm.database.ObjectAccessor;
  import org.sourceforge.jemm.database.components.interfaces.DBGarbageSweeper;
  import org.sourceforge.jemm.database.components.interfaces.DBObjectHandler;
  import org.sourceforge.jemm.database.components.se.StorageEngineGCIF;
  import org.sourceforge.jemm.database.components.types.GCInfo;
  import org.sourceforge.jemm.types.ID;
  import org.sourceforge.jemm.util.LockManager;
  
  /**
   * @author Rory Graves
   *
   */
  public class DefaultDBGarbageSweeper implements DBGarbageSweeper {
  	
  	private static final Logger LOG = Logger.getLogger(DefaultDBGarbageSweeper.class);
  	
      private final ObjectAccessor objectAccessor;
      private final StorageEngineGCIF gcIF;    
      private final LockManager<ID> gcLock = new LockManager<ID>();
      
      private GCMode gcMode;
      private ObjectStatusListenerImpl osListener = new ObjectStatusListenerImpl();
      
      private volatile boolean shutdown = false;
  
  	private final CountDownLatch shutdownLatch = new CountDownLatch(1);
  	
  
      private class ObjectStatusListenerImpl implements ObjectStatusListener {
  		@Override
  		public void initialisationComplete(ID id) {
  			try {
  				gcLock.acquire(id);
  				GCInfo info = gcIF.get(id);
  				info.initFinished();
  				gcIF.save(info);				
  			}finally {
  				gcLock.release(id);
  			}
  		}
  
  		@Override
  		public void objectCreated(ID id) {
  			try {
  				gcLock.acquire(id);
  				GCInfo info = new GCInfo(id);
  				gcIF.save(info);				
  			}finally {
  				gcLock.release(id);
  			}
  		}
  
  		@Override
  		public void rootRefAdded(ID id) {
  			try {
  				gcLock.acquire(id);
  				GCInfo info = gcIF.get(id);
  				info.incrementRootCount();
  				gcIF.save(info);				
  			}finally {
  				gcLock.release(id);
  			}
  		}
  
  		@Override
  		public void rootRefCleared(ID id) {
  			try {
  				gcLock.acquire(id);
  				GCInfo info = gcIF.get(id);
  				info.decrementRootCount();
  				gcIF.save(info);				
  			}finally {
  				gcLock.release(id);
  			}
  		}
  
  		@Override
  		public void clientRefAdded(ID id) {
  			try {
  				gcLock.acquire(id);
  				GCInfo info = gcIF.get(id);
  				info.incrementClientRefCount();
  				gcIF.save(info);				
  			}finally {
  				gcLock.release(id);
  			}
  		}
  
 		@Override
 		public void clientRefCleared(ID id) {
 			try {
 				gcLock.acquire(id);
 				GCInfo info = gcIF.get(id);
 				info.decrementClientRefCount();
 				gcIF.save(info);				
 			}finally {
 				gcLock.release(id);
 			}
 		}
     }
     
     private class Sweeper implements Runnable {
 
         @Override
         public void run() {
         	boolean done = false;
             while(!done) {
             	if(!shutdown)
             		pause(100);
 
             	if(shutdown) {
                 	shutdownLatch.countDown();
                 	done = true;
                 } else {
                 	try {
                 		internalRunGCCycle();
                 	}catch(Exception e) {
                 		LOG.error("Error generated whilst performing GC",e);
                 	}
             	}
             }            
         }
 
         private void pause(long time) {
             try {
                 Thread.sleep(time);                    
             } catch (InterruptedException e) {
                 e.printStackTrace();
             }
         }
     }
     
     public DefaultDBGarbageSweeper(StorageEngine storageEngine,DBObjectHandler objectHandler,GCMode gcMode) {
     	this.gcIF = storageEngine.getGCIF();
         this.objectAccessor = objectHandler;
         this.gcMode = gcMode;
         if(gcMode == GCMode.AUTO) {
             Thread thread = new Thread(new Sweeper());
             thread.setDaemon(true);
             thread.start();
         }
     }
     
     private int internalRunGCCycle() {
         gcInitialise();
         boolean modified;
         do {
         	modified = gcVisitPass(); 
         }while(modified);
         
         int cleaned = gcCleanup();
         return cleaned;
     }
     
     private int gcCleanup() {
     	int count = 0;
     	for (Iterator<ID> itr = objectAccessor.idIterator(); itr.hasNext();) {
 			ID id = itr.next();
 			try {
 				gcLock.acquire(id);
 				GCInfo info = gcIF.get(id);
 				if(!info.isLive()) {
 	        		objectAccessor.removeObject(id);
 					gcIF.remove(id);
 	        		count++;
 				}
 			}finally {
 				gcLock.release(id);
 			}
 		}
     	
     	return count;    	
     }
     
     private void gcInitialise() {
     	for (Iterator<ID> itr = objectAccessor.idIterator(); itr.hasNext();) {
 			ID id = itr.next();
 		
 			try {
 				gcLock.acquire(id);
 				GCInfo info = gcIF.get(id);
 				if(info.gcInitialise())
 					gcIF.save(info);
 			}finally {
 				gcLock.release(id);
 			}
 		}
     }
 
     private boolean gcVisitPass() {
     	boolean changed = false;
     	for (Iterator<ID> itr = objectAccessor.idIterator(); itr.hasNext();) {
 			ID id = itr.next();
 			boolean objChanged = visitObject(id);
 			
 			if(objChanged) {
 				touchChildren(id);
 				changed = true;
 			}
 		}
         return changed;
     }
 
     private boolean visitObject(ID id) {
     	boolean objChanged = false;
 		try {
 			gcLock.acquire(id);
 			GCInfo info = gcIF.get(id);
 	        if(info.getGCStatus() == GCStatus.GREY) {
 	            info.setGCStatus(GCStatus.BLACK);
 				gcIF.save(info);				
 	            objChanged = true;
 	        }
 							
 		}finally {
 			gcLock.release(id);
 		}
 		return objChanged;
     }
     
     private void touchObect(ID id) {
 		try {
 			gcLock.acquire(id);
 			GCInfo info = gcIF.get(id);
 			boolean changed = info.touch();
 			if(changed)
 				gcIF.save(info);				
 		} finally {
 			gcLock.release(id);
 		}
     }
     
     private void touchChildren(ID id) {
     	Set<ID> childrenIds = objectAccessor.getObjectChildren(id);
     	
     	if(childrenIds.size() > 0)
     		for (ID childId : childrenIds)
     			touchObect(childId);
 	}
 
 	public void runGCCycle() {
         if(gcMode == GCMode.AUTO)
             throw new IllegalStateException("Cannot manually trigger MemoryStore gc whilst running in auto mode");
 
         internalRunGCCycle();
     }
 
 	public ObjectStatusListener getObjectStatusListener() {
 		return osListener;
 	}
 
 	@Override
 	public void shutdown() {
 		shutdown = true;
 		if(gcMode == GCMode.AUTO)
 			try {
 				if(!shutdownLatch.await(5000,TimeUnit.MILLISECONDS))
 					LOG.error("Timeout whilst waiting for GC shutdown");
 			} catch (InterruptedException e) {
 				LOG.error("InterruptedException thrown whilst waiting for shutdown",e);
 			}
 	}
 }