/*
    * $HeadURL: https://mindtreeinsight.svn.sourceforge.net/svnroot/mindtreeinsight/insight/insight-ui/trunk/src/main/java/com/mindtree/techworks/insight/ResourceManager.java $
    * $Date: 2008-01-15 19:53:53 -0700 (Tue, 15 Jan 2008) $
    * $Revision: 135 $
    * $Author: bindul $
    * 
    * Copyright (c) 2007 MindTree Consulting Ltd. 
    * 
    * This file is part of Insight.
   * 
   * Insight is free software: you can redistribute it and/or modify it under the 
   * terms of the GNU General Public License as published by the Free Software 
   * Foundation, either version 3 of the License, or (at your option) any later 
   * version.
   * 
   * Insight is distributed in the hope that it will be useful, but 
   * WITHOUT ANY WARRANTY; without even the implied warranty of 
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General 
   * Public License for more details.
   * 
   * You should have received a copy of the GNU General Public License along with 
   * Insight.  If not, see <http://www.gnu.org/licenses/>.
   */
  package com.mindtree.techworks.insight;
  
  import java.awt.Image;
  import java.awt.Toolkit;
  import java.awt.image.ImageProducer;
  import java.io.File;
  import java.io.IOException;
  import java.net.URL;
  import java.security.AccessController;
  import java.security.PrivilegedAction;
  import java.util.HashMap;
  import java.util.Locale;
  import java.util.Map;
  import java.util.ResourceBundle;
  
  import javax.swing.ImageIcon;
  
  /**
   * A simple resource manager implementation for Insight. This implementation
   * starts with loading images, but can be extended for i18n implementation
   * later.
   * 
   * @author <a href="mailto:bindul_bhowmik@mindtree.com">Bindul Bhowmik</a>
   * @version $Revision: 135 $ $Date: 2008-01-15 19:53:53 -0700 (Tue, 15 Jan 2008) $
   */
  public final class ResourceManager {
  
  	/**
  	 * The singleton instance of the class
  	 */
  	private static ResourceManager instance = new ResourceManager();
  	
  	/**
  	 * The resource bundle to load images from
  	 */
  	private static final String imageResourceBundle = "com.mindtree.techworks.insight.images";
  	
  	/**
  	 * The resource bundle with the location of images.
  	 */
  	private ResourceBundle imageLocResourceBundle;
  	
  	/**
  	 * The default locale of the run
  	 */
  	private Locale defaultLocale;	// Initialized in the constructor
  	
  	/**
  	 * The cache used to store loaded images
  	 */
  	private Map imageIconCache;
  	
  	/**
  	 * Mutex used to synchronize write access to the image icon cache
  	 */
  	private Object imageCacheMutex = new Object();
  	
  	/**
  	 * The private constructor to maintain the singleton.
  	 */
  	private ResourceManager () {
  		this.defaultLocale = Locale.getDefault();
  		imageIconCache = new HashMap();
  		
  		// Instantiate the resource bundles
  		imageLocResourceBundle = ResourceBundle.getBundle(imageResourceBundle);
  	}
  	
  	/**
  	 * Gets the singleton instance of the resource manager.
  	 * @return The Resource Manager instance.
  	 */
  	public static ResourceManager getInstance() {
  		return instance;
  	}
  	
 	/**
 	 * Loads an {@link Image} using the image key and the classloader provided.
 	 * @param resourcePath The classpath relative path to the image
 	 * @param classloader The classloader to use to load the image
 	 * @return The loaded image or <code>null</code> if one cannot be loaded
 	 */
 	private Image loadImage (final String resourcePath, final ClassLoader classLoader) {
 		
 		Image loadedImage = null;
 		try {
 			
 			// First try the old way to get the image
 			String insightHomeResourcePath = System
 					.getProperty(InsightConstants.INSIGHT_HOME)
 					+ File.separator + resourcePath;
 			File insightHomeResourceFile = new File(insightHomeResourcePath);
 			if (insightHomeResourceFile.exists()) {
 				loadedImage = new ImageIcon(insightHomeResourceFile.getAbsolutePath()).getImage();
 			}
 			
 			// If not found use the 'new' way
 			if (null == loadedImage) {
 				ImageProducer imageProducer = (ImageProducer) AccessController.doPrivileged(new PrivilegedAction() {
 	
 					public Object run() {
 						Object returnContent = null;
 						URL imageUrl = classLoader.getResource(resourcePath);
 						if (null != imageUrl) {
 							try {
 								returnContent = imageUrl.getContent();
 							} catch (IOException e) {
 								// Ignore
 								// TODO Log later
 							}
 						}
 						return returnContent;
 					}});
 	
 	            if (null != imageProducer) {
 	            	loadedImage = Toolkit.getDefaultToolkit().createImage(imageProducer);
 	            }
 			}
         }
         catch (Exception ex) {
             // Ignore
         	// TODO Log later
         }
 
         return loadedImage;
 	}
 	
 	/**
 	 * Resolves the image key and returns the locale specific image.
 	 * @param imageKey The image key to resolve
 	 * @return The resolved image key
 	 */
 	private String getResolvedImagekey (String imageKey) {
 		String resolvedKey = imageLocResourceBundle.getString(imageKey);
 		if (null == resolvedKey || resolvedKey.trim().length() == 0) {
 			// Fallback to english with no language
 			ResourceBundle defaultResourceBundle = ResourceBundle.getBundle(imageResourceBundle, Locale.ENGLISH);
 			resolvedKey = defaultResourceBundle.getString(imageKey);
 			if (null == resolvedKey || resolvedKey.trim().length() == 0) {
 				resolvedKey = imageKey;
 			}
 		}
 		return resolvedKey;
 	}
 	
 	/**
 	 * Loads an image from the classpath with the relative key passed in. The
 	 * default classloader of this class is used.
 	 * @param imageKey The key to the image
 	 * @return The loaded image
 	 */
 	public ImageIcon loadImageIcon (String imageKey) {
 		return loadImageIcon(imageKey, getClass().getClassLoader());
 	}
 	
 	/**
 	 * Loads an image icon using the image key passed in and the class loader.
 	 * The loaded images are cached, and further requests for the same key
 	 * are resolved from the cache.
 	 * @param imageKey The key to the image
 	 * @param classLoader The classloader to use
 	 * @return The loaded image
 	 */
 	public ImageIcon loadImageIcon (String imageKey, ClassLoader classLoader) {
 		String resolvedImageKey = getResolvedImagekey(imageKey);
 		
 		// Check if we have it in the cache
 		ImageIcon imageIcon = (ImageIcon) imageIconCache.get(resolvedImageKey);
 		
 		if (null == imageIcon) {
 			// Not found in cache... load it
 			synchronized (imageCacheMutex) {
 				// Check if someone else loaded it
 				imageIcon = (ImageIcon) imageIconCache.get(resolvedImageKey);
 				if (null == imageIcon) {
 					Image imageForIcon = loadImage(resolvedImageKey, classLoader);
 					if (null != imageForIcon) {
 						imageIcon = new ImageIcon(imageForIcon);
 						imageIconCache.put(resolvedImageKey, imageIcon);
 					} else {
 						imageIcon = new ImageIcon();
 					}
 				}
 			}
 			
 		}
 		
 		return imageIcon;
 	}
 
 	/**
 	 * @return the defaultLocale
 	 */
 	public Locale getDefaultLocale() {
 		return defaultLocale;
 	}
 }