/******************************************************************************
    * MosaicEngine.java - Base class for the Mosaic engines
    * 
    * PicMan - The BuckoSoft Picture Manager in Java
    * Copyright(c) 2007 - Dick Balaska
    * 
    */
   package com.buckosoft.PicMan.business.mosaic;
   
  import java.awt.image.BufferedImage;
  import java.io.File;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.LinkedList;
  
  import javax.imageio.ImageIO;
  import javax.imageio.ImageWriter;
  import javax.imageio.stream.ImageOutputStream;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  import com.buckosoft.PicMan.business.PicManFacade;
  import com.buckosoft.PicMan.business.util.CopyFile;
  import com.buckosoft.PicMan.db.DatabaseFacade;
  import com.buckosoft.PicMan.domain.JobLogEntry;
  import com.buckosoft.PicMan.domain.Mosaic;
  import com.buckosoft.PicMan.domain.Pic;
  import com.buckosoft.PicMan.domain.Set;
  
  /** Base class for the mosaic engines
   * @author Dick Balaska
   * @since 2007/12/23
   * @see <a href="http://cvs.buckosoft.com/Projects/PicMan/PicMan/src/main/java/com/buckosoft/PicMan/business/mosaic/MosaicEngine.java">MosaicEngine.java</a>
   * @see com.buckosoft.PicMan.business.mosaic.engine
   */
  public class MosaicEngine {
  	protected static boolean DEBUG = false;
  	private final Log logger = LogFactory.getLog(getClass());
  
  	protected	PicManFacade	pmf;
  	protected	DatabaseFacade	dbf;
  
  	protected	Mosaic			mosaic;
  	protected	Pic				masterPic;
  	protected	int				mid;
  	protected	BufferedImage	bi;
  	protected	int				tileHeight = 50;
  	protected	Date			lastMosaicUpdate = new Date(0);
  	protected	Set				mosaicSet;		// The Set to fetch our pics from
  
  	protected	JobLogEntry		jobLogEntry = null;
  
  	/** A hash of all of the configured parameters */
  	protected HashMap<String, ConfigItem>	configMap = new HashMap<String, ConfigItem>();
  	/** The names of the configured parameters, so we can pull them in a reasonable order for display. */
  	protected LinkedList<String>			configList = new LinkedList<String>();
  
  	protected HashMap<String, Object>	buildParameters = new HashMap<String, Object>();
  
  	/** Default constructor
  	 * Base class constructor.  Place your engine config attributes in your constructor. 
  	 */
  	public MosaicEngine() {
  		addConfig("rateWeight", "rate multiplier when selecting pics", ConfigItem.TYPE_DOUBLE, 1.0);
  		
  	}
  	/** Set the reference to the PicMan API.
  	 * @param pmf The PicManFacade
  	 */
  	public	void setPicMan(PicManFacade pmf) {
  		this.pmf = pmf;
  		this.dbf = pmf.getDB();
  	}
  
  	/** Enable logger output on this module
  	 * @param debugFlag true == turn on debugging.
  	 */
  	public void setDEBUG(boolean debugFlag) {
  		DEBUG = debugFlag;
  	}
  
  	/**
  	 * @return the lastMosaicUpdate
  	 */
  	public Date getLastMosaicUpdate() {
  		return lastMosaicUpdate;
  	}
  
  	protected void setLastMosaicUpdate() {
  		this.lastMosaicUpdate = new Date();
  	}
  	
  	/** Get the Tile Height / thumbnail height to be used to build this Mosaic.
  	 * This assumes an engine deals in tileHeights, which is true for now.
  	 * @return the tileHeight
  	 */
  	public int getTileHeight() {
 		return tileHeight;
 	}
 
 	/**
 	 * @param tileHeight the tileHeight to set
 	 */
 	public void setTileHeight(int tileHeight) {
 		this.tileHeight = tileHeight;
 	}
 
 	/** Fetch the image that we built / are building.
 	 * @return the bufferedImage
 	 */
 	public BufferedImage getImage() {
 		return bi;
 	}
 	
 	/** Get the name of the Mosaic that we are building.
 	 * @return The Mosaic name from the Mosaic.
 	 */
 	public String	getName() {
 		if (this.mosaic != null)
 			return(this.mosaic.getName());
 		return("No Name");
 	}
 
 	/** Get the name of the master pic that we are building from.
 	 * @return The name of the master pic.
 	 */
 	public String	getMasterPicName() {
 		if (this.mosaic != null)
 			return(this.mosaic.getMasterPic());
 		return("");
 	}
 	/** Get the name of the output file that will be written.
 	 * @return	The User specified output file. i.e. "C:\myMosaics\Mosaic1.jpg"
 	 */
 	public String	getOutputFileName() {
 		if (this.mosaic != null)
 			return(this.mosaic.getOutPic());
 		return("No Filename");
 	}
 
 	/** Fetch how long this Engine has been running.
 	 * @return Something like "1:23:45"
 	 */
 	public String	getDurationAsString() {
 		if (jobLogEntry == null)
 			return("xx:xx");
 		return(jobLogEntry.getDurationAsString());
 	}
 
 	/** Set the Mosaic that we are going to build.
 	 * @param mosaic The Mosaic parameters as specified by the User.
 	 */
 	public	void	setMosaic(Mosaic mosaic) {
 		this.mosaic = mosaic;
 		this.mosaicSet = pmf.getDB().getSet(mosaic.getSid());
 		this.masterPic = pmf.getDB().getPic(mosaic.getMasterPic());
 		this.mid = mosaic.getMid();
 		this.tileHeight = mosaic.getTileHeight();
 		this.setupBuildParameters();
 		this.bi = pmf.getPicReader().readPic(this.masterPic);
 		setLastMosaicUpdate();
 	}
 
 
 	/** Write the built image to the jpg specified in outPic
 	 * @param makeBackup Maintain a set of backups of the output mosaic.
 	 */
 	public	void	outputMosaicFile(boolean makeBackup) {
 		Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName("jpg");
 		ImageWriter writer = (ImageWriter)writers.next();
 		File file = new File(this.mosaic.getOutPic());
 		if (DEBUG)
 			logger.info("Writing jpg to '" + file.getPath() + "'");
 		try {
 			ImageOutputStream oos = ImageIO.createImageOutputStream(file);
 			writer.setOutput(oos);
 			writer.write(bi);
 			oos.close();
 		} catch (Exception e) {
 //			bi = null;
 			pmf.addError(new Exception ("Can't write jpeg to '"+ file.getPath() + "'",e));
 			return;
 		}
 		if (makeBackup)
 			CopyFile.makeBackup(pmf, file);
 	}
 
 	/** Build the Mosaic.
 	 * @return true if there is more work to do.
 	 * @throws Exception Something went wrong.
 	 */
 	public boolean build() throws Exception {
 		jobLogEntry = new JobLogEntry();
 		jobLogEntry.setType(JobLogEntry.MOSAIC);
 		jobLogEntry.setName(this.mosaic.getName());
 		pmf.addJobToLog(jobLogEntry);
 		this.mosaic.setStartTime(new Date());
 		boolean ret = false;
 		try {
 			ret = _build();
 		} catch (Exception e) {
 			jobLogEntry.setEndTime();
 			throw e;
 		}
 		jobLogEntry.setEndTime();
 		if (!mosaic.isBatch())
 			pmf.getDB().storeMosaic(mosaic);
 		outputMosaicFile(mosaic.isMakeBackup());
 		return(ret);
 	}
 
 	protected boolean _build() throws Exception {
 		throw new Exception("Should be overridden");
 		
 	}
 
 	/** Get the engine's build status.  This should be overridden by the actual engine.
 	 * @return i.e. SecondRibbon returns "Calc: pass=13 p=901"
 	 */
 	public String getStatus() {
 		return("Should be overridden");
 	}
 	
 	/** Get the engine's semi-static build info.  This should be overridden by the actual engine.
 	 * @return i.e. SecondRibbon returns "tileRows=154 maxCol=2048 pics=5820"
 	 */
 	public String getInfo() {
 		return("Should be overridden");
 	}
 	
 	/** Support for runtime MosaicEngine configuration.
 	 * These define the available configurable attributes for an engine.
 	 * @author Dick Balaska
 	 * @since 2009/07/17
 	 * @version $Revision: 1.5 $ <br> $Date: 2014/06/21 04:35:32 $
 	 * @see MosaicEngine
 	 */
 	public class ConfigItem {
 		public final static int TYPE_STRING 	= 1;
 		public final static int TYPE_INT 		= 2;
 		public final static int TYPE_DOUBLE		= 3;
 		public final static int TYPE_BOOLEAN	= 4;
 
 		private String	name;
 		private String	description;
 		@SuppressWarnings("unused")
 		private int		order;			// aborted attempt to display the config fields in order
 		private int		type;
 		private int		valueInt;
 		private double	valueDouble;
 		private String	valueString;
 		
 		/** Construct a ConfigItem with these parameters
 		 * @param name The name of the item
 		 * @param description A description to go in the web page
 		 * @param type String/int/bool/etc.
 		 * @param order The order that this item was entered, for display
 		 */
 		public ConfigItem(String name, String description, int type, int order) {
 			this.name = name;
 			this.description = description;
 			this.type = type;
 			this.order = order;
 		}
 
 		/**
 		 * @return the valueInt
 		 */
 		public int getValueInt() {
 			return valueInt;
 		}
 
 		/**
 		 * @param valueInt the valueInt to set
 		 */
 		public void setValueInt(int valueInt) {
 			this.valueInt = valueInt;
 		}
 
 		/**
 		 * @return the valueDouble
 		 */
 		public double getValueDouble() {
 			return valueDouble;
 		}
 
 		/**
 		 * @param valueDouble the valueDouble to set
 		 */
 		public void setValueDouble(double valueDouble) {
 			this.valueDouble = valueDouble;
 		}
 
 		/**
 		 * @return the valueString
 		 */
 		public String getValueString() {
 			return valueString;
 		}
 
 		/**
 		 * @param valueString the valueString to set
 		 */
 		public void setValueString(String valueString) {
 			this.valueString = valueString;
 		}
 
 		/** Get the name of this ConfigItem.
 		 * @return the name
 		 */
 		public String getName() {
 			return name;
 		}
 
 		/**
 		 * @return the description
 		 */
 		public String getDescription() {
 			return description;
 		}
 
 		/**
 		 * @return the type
 		 */
 		public int getType() {
 			return type;
 		}
 		
 	}
 
 	protected void addConfig(String name, String description, int type, int value) {
 		ConfigItem ci = new ConfigItem(name, description, type, configMap.size());
 		ci.valueInt = value;
 		configMap.put(name, ci);
 		configList.add(name);
 	}
 	protected void addConfig(String name, String description, int type, double value) {
 		ConfigItem ci = new ConfigItem(name, description, type, configMap.size());
 		ci.valueDouble = value;
 		configMap.put(name, ci);
 		configList.add(name);
 	}
 
 	/** A map of the available ConfigItems for an engine.
 	 * @return The map of ConfigItems for this engine keyed by the item name.
 	 */
 	public HashMap<String, ConfigItem> getConfigMap() {
 		return(configMap);
 	}
 	
 	private void setupBuildParameters() {
 		HashMap<String, String> engineConfig = mosaic.getEngineConfig();
 		for (String key : configMap.keySet()) {
 			ConfigItem ci = configMap.get(key);
 			String v = engineConfig.get(key);
 			if (v != null) {
 				switch (ci.type) {
 				case ConfigItem.TYPE_INT:
 					int i = -1;
 					try {
 						i = Integer.parseInt(v);
 					} catch (NumberFormatException e) {
 						pmf.addError(e);
 						logger.info(e);
 						i = -1;
 					}
 					buildParameters.put(key, new Integer(i));
 					break;
 				case ConfigItem.TYPE_DOUBLE:
 					double d = 0.0;
 					try {
 						if (!v.isEmpty())
 							d = Double.parseDouble(v);
 					} catch (NumberFormatException e) {
 						pmf.addError(e);
 						logger.info(e);
 						d = 0.0;
 					}
 					buildParameters.put(key, new Double(d));
 					break;
 				default:
 					Exception e = new Exception("Unhandled type " + ci.type);
 					pmf.addError(e);
 					logger.info(e);
 					break;
 				}
 			} else {
 				switch (ci.type) {
 				case ConfigItem.TYPE_INT:
 					buildParameters.put(key, new Integer(ci.getValueInt()));
 					break;
 				case ConfigItem.TYPE_DOUBLE:
 					buildParameters.put(key, new Double(ci.getValueDouble()));
 					break;
 				default:
 					Exception e = new Exception("Unhandled default type " + ci.type);
 					pmf.addError(e);
 					logger.info(e);
 					break;
 				}
 			}
 		}
 	}
 }