//----------------------------BEGIN LICENSE----------------------------
/* 
 * Willow : the Open Source WorkFlow Project
 * Distributable under GNU LGPL license by gun.org
 *
 * Copyright (C) 2004-2010  huihoo.org 
 * Copyright (C) 2004-2010  ZosaTapo <dertyang@hotmail.com> 
 * 
 * ====================================================================
 * Project Homepage : http://www.huihoo.org/willow
 * Source Forge     : http://sourceforge.net/projects/huihoo
 * Mailing list     : willow@lists.sourceforge.net 
 */
//----------------------------END  LICENSE-----------------------------
package org.huihoo.workflow.coreImpl.util;

import java.text.MessageFormat;
import java.util.*;

/**
 * An internationalization / localization helper class which reduces
 * the bother of handling ResourceBundles and takes care of the
 * common cases of message formating which otherwise require the
 * creation of Object arrays and such.
 *
 * <p>The StringManager operates on a package basis. One StringManager
 * per package can be created and accessed via the getManager method
 * call.
 *
 * <p>The StringManager will look for a ResourceBundle named by
 * the package name given plus the suffix of "LocalStrings". In
 * practice, this means that the localized information will be contained
 * in a LocalStrings.properties file located in the package
 * directory of the classpath.
 *
 * <p>Please see the documentation for java.util.ResourceBundle for
 * more information.
 * @see java.util.ResourceBundle
 */

public class StringManager 
{
    
		/**
		 * The ResourceBundle for this StringManager.
		 */

		private ResourceBundle bundle;

		/**
		 * Creates a new StringManager for a given package. This is a
		 * private method and all access to it is arbitrated by the
		 * static getManager method call so that only one StringManager
		 * per package will be created.
		 *
		 * @param packageName jName of package to create StringManager for.
		 */

		private StringManager(String packageName) 
		{
			this( packageName, Locale.getDefault() );
		}

		private StringManager(String packageName,Locale loc )
		{
				String bundleName = packageName + ".LocalStrings";
				try 
				{
						bundle = ResourceBundle.getBundle(bundleName,loc);
				} 
				catch( MissingResourceException ex ) 
				{
					bundle = ResourceBundle.getBundle(bundleName, Locale.US );
				}
		}

		private StringManager(ResourceBundle bundle )
		{
			this.bundle=bundle;
		}

		/**
				Get a string from the underlying resource bundle or return
				null if the String is not found.
     
				@param key to desired resource String
				@return resource String matching <i>key</i> from underlying
								bundle or null if not found.
				@throws IllegalArgumentException if <i>key</i> is null.        
		 */

		public String getString(String key) 
		{
			if(key == null)
			{
				String msg = "key may not have a null value";
				throw new IllegalArgumentException(msg);
			}

			String str = null;

			try
			{
				str = bundle.getString(key);
			}
			catch(MissingResourceException mre)
			{
				//bad: shouldn't mask an exception the following way:
				//   str = "[cannot find message associated with key '" + key + "' due to " + mre + "]";
				//     because it hides the fact that the String was missing
				//     from the calling code.
				//good: could just throw the exception (or wrap it in another)
				//      but that would probably cause much havoc on existing
				//      code.
				//better: consistent with container pattern to
				//      simply return null.  Calling code can then do
				//      a null check.
				str = null;
			}

			return str;
		}

		/**
		 * Get a string from the underlying resource bundle and format
		 * it with the given set of arguments.
		 *
		 * @param key
		 * @param args
		 */

		public String getString(String key, Object[] args) 
		{
				String iString = null;
				String value = getString(key);

				// this check for the runtime exception is some pre 1.1.6
				// VM's don't do an automatic toString() on the passed in
				// objects and barf out

				try 
				{
					// ensure the arguments are not null so pre 1.2 VM's don't barf
					if(args==null)
					{
						args = new Object[1];
					}
            
					Object[] nonNullArgs = args;
					for (int i=0; i<args.length; i++) 
					{
						if (args[i] == null) 
						{
							if (nonNullArgs==args)
							{
								nonNullArgs=(Object[])args.clone();
							}
							nonNullArgs[i] = "null";
						}
					}
					iString = MessageFormat.format(value, nonNullArgs);
				} 
				catch (IllegalArgumentException iae) 
				{
					StringBuffer buf = new StringBuffer();
					buf.append(value);
					for (int i = 0; i < args.length; i++) 
					{
						buf.append(" arg[" + i + "]=" + args[i]);
					}
					iString = buf.toString();
				}
				return iString;
		}

		/**
		 * Get a string from the underlying resource bundle and format it
		 * with the given object argument. This argument can of course be
		 * a String object.
		 *
		 * @param key
		 * @param arg
		 */

		public String getString(String key, Object arg) 
		{
			Object[] args = new Object[] {arg};
			return getString(key, args);
		}

		/**
		 * Get a string from the underlying resource bundle and format it
		 * with the given object arguments. These arguments can of course
		 * be String objects.
		 *
		 * @param key
		 * @param arg1
		 * @param arg2
		 */

		public String getString(String key, Object arg1, Object arg2) 
		{
			Object[] args = new Object[] {arg1, arg2};
			return getString(key, args);
		}
    
		/**
		 * Get a string from the underlying resource bundle and format it
		 * with the given object arguments. These arguments can of course
		 * be String objects.
		 *
		 * @param key
		 * @param arg1
		 * @param arg2
		 * @param arg3
		 */

		public String getString(String key, Object arg1, Object arg2,Object arg3)
		{
			Object[] args = new Object[] {arg1, arg2, arg3};
			return getString(key, args);
		}

		/**
		 * Get a string from the underlying resource bundle and format it
		 * with the given object arguments. These arguments can of course
		 * be String objects.
		 *
		 * @param key
		 * @param arg1
		 * @param arg2
		 * @param arg3
		 * @param arg4
		 */

		public String getString(String key, Object arg1, Object arg2,Object arg3, Object arg4) 
		{
			Object[] args = new Object[] {arg1, arg2, arg3, arg4};
			return getString(key, args);
		}
		// --------------------------------------------------------------
		// STATIC SUPPORT METHODS
		// --------------------------------------------------------------

		private static Hashtable managers = new Hashtable();

		/**
		 * Get the StringManager for a particular package. If a manager for
		 * a package already exists, it will be reused, else a new
		 * StringManager will be created and returned.
		 *
		 * @param packageName
		 */
		public synchronized static StringManager getManager(String packageName)
		{
			StringManager mgr = (StringManager)managers.get(packageName);
			if (mgr == null)
			{
				mgr = new StringManager(packageName);
				managers.put(packageName, mgr);
			}
			return mgr;
		}

		/**
		 * Get the StringManager for a particular package. If a manager for
		 * a package already exists, it will be reused, else a new
		 * StringManager will be created and returned.
		 *
		 * @param packageName
		 */
		public synchronized static StringManager getManager(ResourceBundle bundle) 
		{
			return new StringManager( bundle );
		}


		/**
		 * Get the StringManager for a particular package and Locale. If a manager for
		 * a package already exists, it will be reused, else a new
		 * StringManager will be created for that Locale and returned.
		 *
		 *
		 * @param packageName
		 */

	 public synchronized static StringManager getManager(String packageName,Locale loc) 
	 {
			StringManager mgr = (StringManager)managers.get(packageName+"_"+loc.toString());
			if (mgr == null)
			{
				mgr = new StringManager(packageName,loc);
				managers.put(packageName+"_"+loc.toString(), mgr);
			}
			return mgr;
		}

}

