/******************************************************************************
    * MosaicMan.java - Manage mosaic activities
    * 
    * PicMan - The BuckoSoft Picture Manager in Java
    * Copyright(c) 2007 - Dick Balaska
    * 
    */
   package com.buckosoft.PicMan.business.mosaic;
   
  import java.util.Iterator;
  import java.util.LinkedList;
  import java.util.List;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.buckosoft.PicMan.business.PicManFacade;
  import com.buckosoft.PicMan.domain.Mosaic;
  
  /** Manage mosaic building activities
   * @author Dick Balaska
   * @since 2007/12/01
   * @version $Revision: 1.3 $ <br> $Date: 2014/06/21 04:35:32 $
   * @see <a href="http://cvs.buckosoft.com/Projects/PicMan/PicMan/src/main/java/com/buckosoft/PicMan/business/mosaic/MosaicMan.java">MosaicMan.java</a>
   */
  public class MosaicMan {
  	private static boolean DEBUG = false;
  	private static boolean DEBUGEngine = false;
  	protected final Log logger = LogFactory.getLog(getClass());
  
  	private	PicManFacade	pmf;
  
  	private	boolean	building = false;
  	
  	private	Mosaic			mosaicBuilding;
  	private	MosaicEngine	mosaicEngine;
  	
  	private	MosaicManDevelopment	mosaicManDevelopment = new MosaicManDevelopment();
  
  	/** A List of Mosaics to be built.  The head entry is built and new ones are added to the tail. */
  	private	LinkedList<Mosaic>	mosaicList = new LinkedList<Mosaic>();
  	
  	/** Set the reference to the PicMan API.
  	 * @param pmf The PicManFacade
  	 */
  	public	void setPicMan(PicManFacade pmf) {
  		this.pmf = pmf;
  		mosaicManDevelopment.setPicMan(pmf);
  	}
  
  	/** Enable logger output on this module
  	 * @param debugFlag true == turn on debugging.
  	 */
  	public void setDEBUG(boolean debugFlag) {
  		DEBUG = debugFlag;
  	}
  
  	/** Enable logger output on any MosaicEngine spawned.
  	 * @param debugFlag true == turn on debugging.
  	 */
  	public void setDEBUGEngine(boolean debugFlag) {
  		DEBUGEngine = debugFlag;
  	}
  
  	/** Fetch a reference to the MosaicManDevelopment
  	 * @return the mosaicManDevelopment
  	 */
  	public MosaicManDevelopment getMosaicManDevelopment() {
  		return mosaicManDevelopment;
  	}
  
  	/** If Mosaic is running, return a reference to the running engine.
  	 * @return the mosaicEngine
  	 */
  	public MosaicEngine getMosaicEngine() {
  		return mosaicEngine;
  	}
  
  	/** Manage synchronized access to the list.
  	 * There are two operations, remove head (mosaic == null)
  	 * and add tail (mosaic != null)
  	 * @param mosaic
  	 */
  	private	synchronized void addToMosaicList(Mosaic mosaic) {
  		if (mosaic == null) {
  			if (mosaicList.size() > 0)
  				mosaicList.removeFirst();
  			return;
  		}
  		mosaicList.add(mosaic);
  	}
  
  	/** Are we running the builder?
  	 * @return the building
  	 */
  	public boolean isBuilding() {
  		return(this.building);
  	}
  	
 	/** Is there work to be done?  i.e. should we run the builder?
 	 * @return true if there are Mosaics queued to be built
 	 */
 	public boolean hasWorkToDo() {
 		return(this.mosaicList.size() != 0);
 	}
 
 	/** Return a List of the names of Mosaic jobs queued to be run.
 	 * @return The list of Mosaic Names
 	 */
 	public List<String> getMosaicQueueListString() {
 		LinkedList<String> list = new LinkedList<String>();
 		Iterator<Mosaic>	iter = mosaicList.iterator();
 		while (iter.hasNext()) {
 			Mosaic m = iter.next();
 			list.add(m.getName());
 		}
 		return(list);
 	}
 	
 	/** Queue this Mosaic for building.
 	 * @param mosaic The Mosaic that the User wants built
 	 */
 	public void queueForBuilding(Mosaic mosaic) {
 		this.addToMosaicList(mosaic);
 		if (DEBUG)
 			logger.info("Start building " + mosaic.getName());
 	}
 
 	/** Remove any and all jobs from the Mosaic queue
 	 * @return The number of jobs removed
 	 */
 	public int emptyMosaicQueue() {
 		int i = this.mosaicList.size();
 		this.mosaicList.clear();
 		return(i);
 	}
 
 	/** Build the first mosaic in the list. <br>
 	 * Returns after the first mosaic is built.  BatchManager will come around again on it's next iteration
 	 * if there is more work to do.
 	 * @return true if there is more work to do on this mosaic.
 	 * @throws Exception Something went wrong.
 	 */
 	public boolean runBuilder() throws Exception {
 		boolean moreWork = false;
 		this.mosaicBuilding = this.mosaicList.getFirst();
 		if (this.mosaicBuilding == null)
 			return(false);
 		try {
 			mosaicEngine = (MosaicEngine)Class.forName("com.buckosoft.PicMan.business.mosaic.engine."
 							+ mosaicBuilding.getEngine()).newInstance();
 		} catch (Exception e) {
 			Exception ex = new Exception("Can't instantiate Mosaic Engine: " + mosaicEngine, e);
 			pmf.addError(ex);
 			return(false);
 		}
 		mosaicEngine.setPicMan(pmf);
 		mosaicEngine.setDEBUG(DEBUGEngine);
 		mosaicEngine.setMosaic(this.mosaicBuilding);
 		pmf.setupMosaicThumbCache(this.mosaicBuilding.getSid(), this.mosaicBuilding.getTileHeight());
 		this.building = true;
 		try {
 			moreWork = mosaicEngine.build();
 		} catch (Exception e) {
 			this.building = false;
 			this.mosaicEngine = null;
 			this.addToMosaicList(null);
 			throw e;
 		}
 		this.building = moreWork;
 		if (!moreWork) {
 			this.mosaicEngine = null;
 			this.addToMosaicList(null);
 			this.pmf.releaseMosaicThumbCache();
 		}
 		return(moreWork);
 	}
 
 	/** Write the (possibly partially completed) mosaic output jpeg
 	 */ 
 	public void outputMosaicFile() {
 		if (this.mosaicEngine == null) {
 			Exception e = new Exception("No mosaic to save");
 			pmf.addError(e);
 			return;
 		}
 		// don't make the backup if we are writing from a user click.
 		this.mosaicEngine.outputMosaicFile(false);
 	}
 }