/******************************************************************************
    * ThumbCache.java - Manage a cache of thumnails
    * 
    * PicMan - The BuckoSoft Picture Manager in Java
    * Copyright(c) 2006 - Dick Balaska
    * 
    */
   package com.buckosoft.PicMan.image;
   
  import java.awt.Graphics2D;
  import java.awt.Image;
  import java.awt.image.BufferedImage;
  import java.io.File;
  import java.io.IOException;
  import java.util.Date;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  
  import javax.imageio.ImageIO;
  import javax.imageio.ImageReader;
  import javax.imageio.ImageWriter;
  import javax.imageio.stream.ImageInputStream;
  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.domain.JobLogEntry;
  import com.buckosoft.PicMan.domain.Pic;
  import com.buckosoft.PicMan.domain.Thumbnail;
  
  /** Manage the Thumb Cache.  If a Pic is requested that is equal to or smaller than the cache height,
   * see if there is a cached version on the disk.  It is <i>much</i> faster to read a 3KB file than
   * a 1MB file.
   *   
   * @author Dick Balaska
   * @since 2006/01/27
   * @see <a href="http://cvs.buckosoft.com/Projects/java/PicMan/PicMan/src/com/buckosoft/PicMan/image/ThumbCache.java">ThumbCache.java</a>
   */ 
  public class ThumbCache {
  	private	static final boolean DEBUG = false;
  	private	static final boolean DEBUGHITS = false;
  	protected final Log logger = LogFactory.getLog(getClass());
  
  	private	PicManFacade	pmf;
  	//private	DatabaseFacade	db;
  	private	boolean		active = false;
  	private	String		thumbExt = "jpg";
  	private	int			cachedHeight = 0;
  	private	String		cacheDirectory;
  	private	int			maxEntriesPerCache = 1000;
  	private	int			currentCacheFillDir = 0;
  	private	int			currentCacheFillCount = 0;
  	private	boolean		buildThumbCache = false;
  	private	boolean		mosaicThumbCache = false;	// special rules
  	private	int			mosaicSet = 0;				// if we are a mosaic cache, what set did we use?
  
  	private	HashMap<Pic, Thumbnail>			mosaicSuperCache = null;
  	private	int								mosaicSuperCacheMaxSize = 6300;
  
  	/** Set the reference to the main API
  	 * @param pmf The PicManFacade
  	 */
  	public	void setPicMan(PicManFacade pmf) {
  		this.pmf = pmf;
  		//this.db = pmf.getDB();
  	}
  
  	/** Are we wanting to build the thumb cache?
  	 * @return the buildThumbCache flag
  	 */
  	public boolean isBuildThumbCache() {
  		return buildThumbCache;
  	}
  
  	/** Fetch the size of the thumbnails that we are managing
  	 * @return The local cachedHeight
  	 */
  	public int getCachedHeight() {
  		return(this.cachedHeight);
  	}
  
  	
  	/**
  	 * @return the mosaicSet
  	 */
  	public int getMosaicSet() {
  		return mosaicSet;
  	}
  
  	/**
  	 * @param mosaicSet the mosaicSet to set
  	 */
  	public void setMosaicSet(int mosaicSet) {
  		this.mosaicSet = mosaicSet;
  		this.mosaicThumbCache = true;
  		//this.mosaicSuperCache = new HashMap<Pic,Thumbnail>();
 	}
 
 	/**
 	 * @return the mosaicSuperCacheMaxSize
 	 */
 	public int getMosaicSuperCacheMaxSize() {
 		return mosaicSuperCacheMaxSize;
 	}
 
 	/** Release any cache buffers we are holding
 	 */
 	public void release() {
 		this.mosaicSuperCache = null;
 	}
 	/**
 	 * @param mosaicSuperCacheMaxSize the mosaicSuperCacheMaxSize to set
 	 */
 	public void setMosaicSuperCacheMaxSize(int mosaicSuperCacheMaxSize) {
 		this.mosaicSuperCacheMaxSize = mosaicSuperCacheMaxSize;
 	}
 
 	/** Build the thumb cache.  Signal to the batch manager to run the builder.
 	 * @param buildThumbCache the buildThumbCache to set
 	 */
 	public void setBuildThumbCache(boolean buildThumbCache) {
 		this.buildThumbCache = buildThumbCache;
 	}
 
 	/** Get a cached Thumbnail. <br>
 	 * If the requested height is smaller than the cached height, then scale the Thumbnail to size. 
 	 * @param pic The Pic who's Thumbnail we want
 	 * @param height The height of the thumbnail we want
 	 * @return A Thumbnail, or null if not cached or if the cached size is smaller than the requested size.
 	 */
 	public	 Thumbnail	getThumbNail(Pic pic, int height) {
 		if (!active)
 			return(null);
 //		if (cachedHeight == 0)
 //			prepareCache();
 		if (height > cachedHeight)
 			return(null);
 		if (!this.mosaicThumbCache && pic.getCacheDir() == 0)
 			return(null);
 		if (this.mosaicSuperCache != null && this.mosaicSuperCache.containsKey(pic))
 			return(this.mosaicSuperCache.get(pic));
 		File f;
 		if (this.mosaicThumbCache)
 			f = new File(this.cacheDirectory,
 						 pic.getName()+ "." + thumbExt);
 		else
 			f = new File(this.cacheDirectory + File.separator + pic.getCacheDir(),
 						 pic.getName()+ "." + thumbExt);
 		Iterator<ImageReader> readers = ImageIO.getImageReadersByFormatName(thumbExt);
 		ImageReader reader = (ImageReader)readers.next();
 		BufferedImage bi;
 		if (DEBUGHITS)
 			logger.info("read: '" + f + "'");
 		ImageInputStream iis = null;
 		try {
 			iis = ImageIO.createImageInputStream(f);
 			if (DEBUGHITS)
 				logger.info("cache " + (iis != null ? "hit " : "miss ") + pic.getName());
 			if (iis == null) {
 				return(null);
 			}
 			reader.setInput(iis, true);
 			bi = reader.read(0);
 			iis.close();
 		} catch (IllegalStateException ise) {
 			if (DEBUG)
 				logger.info("caught IllegalStateException");
 			bi = null;
 			try {
 				iis.close();
 			} catch (IOException e) {}
 			return(null);
 		} catch (Exception e) {
 			if (DEBUG)
 				logger.info("caught Exception");
 			bi = null;
 			try {
 				iis.close();
 			} catch (IOException e1) {}
 			return(null);
 		}
 
 		// Are we making a thumbnail of a thumbnail?  (like, for mosaic)
 		// If so, then rescale the cached thumbnail, which is much faster than reading the original big pic.
 		if (height < cachedHeight) {
 			double	dW = ((double)height/(double)bi.getHeight()) * bi.getWidth();
 			int newW = (int)dW;
 			BufferedImage small = new BufferedImage(newW, height, BufferedImage.TYPE_INT_BGR);
 			Graphics2D	g;
 			g = small.createGraphics();
 			g.drawImage(bi.getScaledInstance(-1, height, Image.SCALE_SMOOTH), null, null);
 			bi = small;
 		}
 
 		Thumbnail tn;
 		tn = new Thumbnail();
 		tn.setName(pic.getName());
 		tn.setImage(bi);
 		bi = null;
 		if (this.mosaicSuperCache != null && this.mosaicSuperCache.size() < this.mosaicSuperCacheMaxSize)
 			this.mosaicSuperCache.put(pic, tn);
 		return(tn);
 	}
 
 	/** Add a thumbnail to the cache
 	 * @param pic The pic that is being cached
 	 * @param tn The thumb to cache
 	 */
 	public	void	addToCache(Pic pic, Thumbnail tn) {
 		if (tn.isXThumb())
 			return;						// don't cache broken thumbs.
 		if (!this.active)
 			return;
 
 		boolean savePic = false;		// must flush pic if cache info changed
 
 		if (tn.getName() == null || tn.getName().length() < 1)
 			throw new RuntimeException("Can't add thumb to cache with no name");
 		if (tn.getImage().getHeight() != cachedHeight)
 			return;
 		if (!this.mosaicThumbCache && pic.getCacheDir() == 0) {
 			pic.setCacheDir(this.currentCacheFillDir);
 			savePic = true;
 		}
 		File file;
 		if (this.mosaicThumbCache)
 			file = new File(this.cacheDirectory,
 							tn.getName() + "." + thumbExt);
 		else
 			file = new File(this.cacheDirectory + File.separator + this.currentCacheFillDir,
 							tn.getName() + "." + thumbExt);
 		if (!file.exists()) {
 			Iterator<ImageWriter> writers = ImageIO.getImageWritersByFormatName(thumbExt);
 			ImageWriter writer = (ImageWriter)writers.next();
 			if (DEBUGHITS)
 				logger.info("Writing '" + file.getPath() + "'");
 			ImageOutputStream oos = null;
 			try {
 				oos = ImageIO.createImageOutputStream(file);
 				writer.setOutput(oos);
 				writer.write(tn.getImage());
 				oos.close();
 			} catch (IOException e) {
 				if (oos != null)
 					try {
 						oos.close();
 					} catch (IOException e1) {
 					}
 				Exception ex = new Exception("Failed to save cache thumb", e);
 				pmf.addError(ex);
 				return;
 			}
 		}
 		if (savePic) {
 			pmf.getDB().updatePic(pic);
 			this.currentCacheFillCount++;
 			if (this.currentCacheFillCount >= this.maxEntriesPerCache) {
 				this.currentCacheFillDir++;
 				prepareCacheDir();
 				this.currentCacheFillCount = pmf.getDB().getPicThumbCacheFillCount(this.currentCacheFillDir);
 				if (DEBUGHITS)
 					logger.info("getPicThumbCacheFillCount returned " + this.currentCacheFillCount);
 			}
 		}
 	}
 
 	/** Initialize the thumbCache */
 	public	void	setupCache(String cacheDir, int cacheHeight, int maxEntriesPerCache) {
 		this.cacheDirectory = cacheDir;
 		this.cachedHeight = cacheHeight;
 		this.maxEntriesPerCache = maxEntriesPerCache;
 		this.active = pmf.getDB().getSystem().isUseThumbCache();
 		if (!this.active)
 			return;
 
 		File f;
 		f = new File(this.cacheDirectory);
 		if (!f.isDirectory()) {
 			JobLogEntry jle = new JobLogEntry();
 			jle.setType(JobLogEntry.INFO);
 			jle.setName("Create Thumb cache");
 			if (!f.mkdirs()) {
 				jle.setName("Failed to create Thumb cache");
 				jle.setError();
 			}
 			jle.setEndTime();
 			pmf.addJobToLog(jle);
 			if (jle.isError())
 				return;
 		}
 		this.currentCacheFillDir = pmf.getDB().getPicMaxThumbCacheDirUsed();
 		if (DEBUG)
 			logger.info("getPicMaxThumbCacheDirUsed returned " + this.currentCacheFillDir);
 		if (this.currentCacheFillDir == 0)
 			this.currentCacheFillDir = 1;
 		this.currentCacheFillCount = pmf.getDB().getPicThumbCacheFillCount(this.currentCacheFillDir);
 		if (DEBUG)
 			logger.info("getPicThumbCacheFillCount returned " + this.currentCacheFillCount);
 		prepareCacheDir();
 	}
 	
 	private void prepareCacheDir() {
 //		if (this.currentCacheFillCount > this.maxEntriesPerCache)
 //			this.currentCacheFillDir++;
 		File dir = new File(this.cacheDirectory + File.separator + this.currentCacheFillDir);
 		if (!dir.isDirectory()) {
 			if (!dir.mkdir()) {
 				// XXX: Error
 			}
 		}
 	}
 	
 	/** Delete the thumb cache. <br>
 	 * Delete all of the files and subdirectories under the thumb cache directory. <br>
 	 * If we are not a mosaicThumbCache, which is an auxillary cache, 
 	 *		then set to 0 all of the cacheDir entries for each pic.
 	 */
 	public void deleteCache() {
 		JobLogEntry jle = new JobLogEntry();
 		if (!mosaicThumbCache) {
 			jle.setType(JobLogEntry.INFO);
 			jle.setName("Delete Cache");
 			pmf.addJobToLog(jle);
 		}
 		File f = new File(this.cacheDirectory);
 		_deleteCache(f);
 		if (mosaicThumbCache)
 			return;
 		List<Pic> list = pmf.getDB().getPics();
 		Iterator<Pic> iter = list.iterator();
 		Pic pic;
 		while (iter.hasNext()) {
 			pic = iter.next();
 			if (pic.getCacheDir() != 0) {
 				pic.setCacheDir(0);
 				pmf.getDB().updatePic(pic);
 			}
 		}
 		jle.setEndTime(new Date());
 	}
 
 	private void _deleteCache(File f) {
 		File[] list = f.listFiles();
 		if (list == null)
 			return;
 		File ff;
 		int	i;
 		for (i=0; i<list.length; i++) {
 			ff = list[i];
 			if (ff.isDirectory())
 				_deleteCache(ff);
 			boolean res = ff.delete();
 			if (!res)
 				ff.delete();
 			if (DEBUG) {
 				if (!res)
 					logger.info("Failed to delete '" + ff.getName() + "'");
 			}
 		}
 	}
 	
 	/** Read each pic with the sole purpose of creating a cache entry for it.
 	 */
 	public void batchBuildCache() throws Exception {
 		JobLogEntry jle = new JobLogEntry();
 		jle.setType(JobLogEntry.INFO);
 		jle.setName("Build Cache");
 		pmf.addJobToLog(jle);
 		List<Pic> list;
 		if (this.mosaicThumbCache)
 			list = pmf.getDB().getPics(pmf.getDB().getSet(this.mosaicSet), this.cachedHeight);
 		else
 			list = pmf.getDB().getPics();
 		Iterator<Pic> iter = list.iterator();
 		Pic pic = null;
 		picProcessing = 0;
 		try {
 			while (iter.hasNext()) {
 				pic = iter.next();
 				picProcessing++;
 				if (pic.getRid() == 0)
 					continue;
 				if (this.mosaicThumbCache) {
 					if (DEBUG)
 						logger.info("Create Mosaic cache entry for '" + pic.getName() + "'");
 					Thumbnail tn = pmf.getPicReader().getThumbNail(pic, this.cachedHeight, null);
 					if (this.mosaicThumbCache)
 						this.addToCache(pic, tn);
 					
 				}
 				else if (pic.getCacheDir() == 0) {
 					if (DEBUG)
 						logger.info("Create cache entry for '" + pic.getName() + "'");
 					pmf.getPicReader().getThumbNail(pic, this.cachedHeight, null);
 				}
 			}
 		} catch (Exception e) {
 			logger.error("batchBuildCache failed on " + pic.getName());
 			jle.setEndTime(new Date());
 			throw new Exception("batchBuildCache failed on " + pic.getName(), e);
 		}		
 		jle.setEndTime(new Date());
 	}
 
 	private int picProcessing = 0;
 	
 	/** Return which pic number we are building during batchBuildCache.
 	 * This is just a status indicator.
 	 * @return The index into the list as we process pics.
 	 */
 	public int getPicProcessing() {
 		return(picProcessing);
 	}
 }