/******************************************************************************

  * 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);

         }

 }