/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of Java-Common.
    *
    * Java-Common 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.
   *
   * Java-Common 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 Java-Common.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.application.state;
  
  import com.cosylab.application.state.impl.CDBStateStorage;
  import com.cosylab.application.state.impl.DefaultState;
  import com.cosylab.application.state.impl.SerialStateStorage;
  import com.cosylab.application.state.impl.TextStateStorage;
  import com.cosylab.application.state.impl.XMLStateStorage;
  
  import java.io.File;
  import java.io.FilenameFilter;
  
  import java.util.HashMap;
  import java.util.Iterator;
  
  
  /**
   * This class is used as the factory for the state exchange objects mainly the
   * <code>State</code> implementation and the <code>StateStorage</code>
   * implementation.
   *
   * @author dvitas
   */
  public final class StateFactory
  {
  	/** DOCUMENT ME! */
  	public static final String STORAGE_BIN = "BIN";
  
  	/** DOCUMENT ME! */
  	public static final String STORAGE_TXT = "TXT";
  
  	/** DOCUMENT ME! */
  	public static final String STORAGE_XML = "XML";
  
  	/** DOCUMENT ME! */
  	public static final String STORAGE_CDB = "CDB";
  
  	/** DOCUMENT ME! */
  	public static final String STORAGE_DAT = "DAT";
  
  	/** DOCUMENT ME! */
  	public static HashMap stateStorages = null;
  
  	/** DOCUMENT ME! */
  	public static String defaultstateStorage = null;
  
  	static {
  		// prepare storage
  		stateStorages = new HashMap(5);
  
  		// register our defaults
  		registerStateStorage(STORAGE_BIN, SerialStateStorage.class.getName());
  		registerStateStorage(STORAGE_TXT, TextStateStorage.class.getName());
  		registerStateStorage(STORAGE_XML, XMLStateStorage.class.getName());
  		registerStateStorage(STORAGE_CDB, CDBStateStorage.class.getName());
  		setDefaultStateStorage(STORAGE_XML);
  
  		// maybe something else
  		String userTypeClass = System.getProperty("StateStorage");
  
  		if(userTypeClass != null) {
  			registerStateStorage(STORAGE_DAT, userTypeClass);
  
  			// if so set it as default
  			setDefaultStateStorage(STORAGE_DAT);
  		}
  
  		// default ?
  		String defaultSS = System.getProperty("DefaultStateStorage");
  
  		if(defaultSS != null) {
  			// if we new it
  			if(stateStorages.get(defaultSS) != null) {
  				setDefaultStateStorage(defaultSS);
  			}
  		}
  	}
  
  	/**
  	 * DOCUMENT ME!
  	 *
 	 * @param type DOCUMENT ME!
 	 * @param className DOCUMENT ME!
 	 */
 	public static void registerStateStorage(final String type,
 	    final String className)
 	{
 		stateStorages.put(type, className);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param type DOCUMENT ME!
 	 */
 	public static void setDefaultStateStorage(final String type)
 	{
 		defaultstateStorage = type;
 	}
 
 	protected static boolean typeExists(final File[] files, final String type)
 	{
 		if(files == null) {
 			return false;
 		}
 
 		for(int i = 0; i < files.length; i++) {
 			if(files[i].getName().endsWith(type)
 			    || files[i].getName().endsWith(type.toLowerCase())) {
 				return true;
 			}
 		}
 
 		return false;
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param filePath DOCUMENT ME!
 	 * @param appName DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 */
 	public static StateStorage createStateStorage(final String filePath,
 	    final String appName)
 	{
 		// first try to gues state storage type from file extension
 		try {
 			// list all files that starts with app name
 			File file = new File(filePath);
 			File[] files = file.listFiles(new FilenameFilter() {
 						public boolean accept(File dir, String name)
 						{
 							if(name.startsWith(appName)) {
 								return true;
 							}
 
 							return false;
 						}
 					});
 
 			// if there is files and none of them is default then find out which storage to use
 			if(!typeExists(files, defaultstateStorage)) {
 				Iterator iter = stateStorages.keySet().iterator();
 
 				while(iter.hasNext()) {
 					String type = (String)iter.next();
 
 					if(typeExists(files, type)) {
 						// try to create it with the delegator
 						StateStorage ss = createStateStorage(type);
 						Class[] paramTypes = { StateStorage.class };
 						Object[] params = { ss };
 
 						return (StateStorage)Class.forName((String)stateStorages
 						    .get(defaultstateStorage)).getConstructor(paramTypes)
 						.newInstance(params);
 					}
 				}
 			}
 		} catch(Exception e) {
 			// no op - will use default
 		}
 
 		return createStateStorage();
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 */
 	public static StateStorage createStateStorage()
 	{
 		return createStateStorage(defaultstateStorage);
 	}
 
 	/**
 	 * DOCUMENT ME!
 	 *
 	 * @param type DOCUMENT ME!
 	 *
 	 * @return DOCUMENT ME!
 	 *
 	 * @throws IllegalArgumentException DOCUMENT ME!
 	 */
 	public static StateStorage createStateStorage(final String type)
 	{
 		String className = (String)stateStorages.get(type);
 
 		if(className == null) {
 			return null;
 		}
 
 		try {
 			Object obj = Class.forName(className).newInstance();
 
 			return (StateStorage)obj;
 		} catch(Exception e) {
 			throw new IllegalArgumentException(e.getMessage());
 		}
 	}
 
 	/**
 	 * Creates new storage with default ID.
 	 *
 	 * @return no-name storage
 	 */
 	public static State createState()
 	{
 		return new DefaultState();
 	}
 }
 
 /* __oOo__ */