/*
    * @(#) DialogPanelFactory.java Oct 27, 2004
    * 
    * 
    * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628 BX
    * Delft, the Netherlands. All rights reserved.
    * 
    * See for project information <a href="http://www.simulation.tudelft.nl/">
    * www.simulation.tudelft.nl </a>.
   * 
   * The source code and binary code of this software is proprietary information
   * of Delft University of Technology.
   */
  package org.gscg.gameleader.dialogs.components;
  
  import java.awt.Color;
  import java.awt.Dimension;
  import java.lang.reflect.Constructor;
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.Map;
  
  import javax.swing.JTabbedPane;
  import javax.swing.SwingConstants;
  import javax.swing.UIManager;
  
  import nl.tudelft.simulation.dsol.simulators.SimulatorInterface;
  import nl.tudelft.simulation.logger.Logger;
  
  /***
   * The DialogPanelFactory is used to create customized JPanels based on the
   * object given to the factory. If the factory is not able to process the
   * selected object, null is returned.
   * <p>
   * 
   * Copyright (c) 2003-2005 Delft University of Technology, Jaffalaan 5, 2628 BX
   * Delft, the Netherlands. All rights reserved.
   * 
   * See for project information <a href="http://www.simulation.tudelft.nl/">
   * www.simulation.tudelft.nl </a>.
   * 
   * The source code and binary code of this software is proprietary information
   * of Delft University of Technology.
   * 
   * @author <a
   *         href="http://www.tbm.tudelft.nl/webstaf/stijnh/index.htm">Stijn-Pieter
   *         van Houten </a>
   * @version $Revision: 1.1 $ $Date: 2005/06/16 12:34:09 $
   * @since 1.0.3
   */
  public final class DialogPanelFactory
  {
  	/*** the simulator to use */
  	private static SimulatorInterface simulator = null;
  
  	/***
  	 * Method setSimulator sets the simulator to use.
  	 * 
  	 * @param simulator the simulator to use
  	 */
  	public static void setSimulator(final SimulatorInterface simulator)
  	{
  		DialogPanelFactory.simulator = simulator;
  	}
  
  	/***
  	 * constructs a new DialogPanelFactory
  	 */
  	private DialogPanelFactory()
  	{
  		// utility classes should not be instantiated
  	}
  
  	/***
  	 * the map contains the known actor objects and is initialized during
  	 * classloading
  	 */
  	private static ArrayList knownActorObjects;
  
  	/***
  	 * Method getPanel returns an panel based on the given object
  	 * 
  	 * @param object the selected object
  	 * @return returns an initialized JPanel if the class of the actor is known,
  	 *         null otherwise
  	 */
  	public static JTabbedPane getPanel(final Object object)
  	{
  		Class objectClass = object.getClass();
  		DialogInterface objectPanel = null;
  
  		// the structure below enables us to use basic panels e.g. for a
  		// supplychain actor
  		// if we would like to use a more customized one (e.g. for a trader),
  		// this one will be used first
  		for (int i = 0; i < DialogPanelFactory.knownActorObjects.size(); i++)
  		{
  			Map map = (Map) DialogPanelFactory.knownActorObjects.get(i);
 
 			for (Iterator it = map.keySet().iterator(); it.hasNext();)
 			{
 				Class clazz = (Class) it.next();
 				if (clazz.isAssignableFrom(objectClass))
 				{
 					objectPanel = (DialogInterface) map.get(clazz);
 					return DialogPanelFactory.createPanel(objectPanel, object);
 				}
 			}
 		}
 		// we failed to find an actor dialog window
 		Logger.severe(DialogPanelFactory.class, "find factory",
 				"Could not find factory for object with class: "
 						+ object.getClass());
 		return null;
 	}
 
 	/***
 	 * Method addFactory allows the adding of panel factories. Based on the
 	 * class, a lookup is performed to determine the correct position of the
 	 * factory in the list of factories. If there was no factory present for the
 	 * given class, the factory is added and true is returned. If there is
 	 * already a factory present, false is returned.
 	 * 
 	 * @param clazz the class to add the factory for
 	 * @param dialogInterface the dialogInterface
 	 * @return returns false if the factory could not be added, e.g. when there
 	 *         is already a factory present for the given class
 	 */
 	public static boolean addFactory(final Class clazz,
 			final DialogInterface dialogInterface)
 	{
 		boolean added = false;
 
 		if (DialogPanelFactory.knownActorObjects == null)
 		{
 			DialogPanelFactory.knownActorObjects = new ArrayList();
 		}
 
 		// we first check whether there is already a factory present
 		for (int i = DialogPanelFactory.knownActorObjects.size() - 1; i >= 0; i--)
 		{
 			Map map = (Map) DialogPanelFactory.knownActorObjects.get(i);
 			for (Iterator it = map.keySet().iterator(); it.hasNext();)
 			{
 				Class key = (Class) it.next();
 				if (clazz.equals(key))
 				{
 					// key is already present, return false
 					return false;
 				}
 			}
 		}
 
 		// we passed the check, add the factory
 		for (int i = DialogPanelFactory.knownActorObjects.size() - 1; i >= 0; i--)
 		{
 			Map map = (Map) DialogPanelFactory.knownActorObjects.get(i);
 			for (Iterator it = map.keySet().iterator(); it.hasNext();)
 			{
 				Class key = (Class) it.next();
 				if (clazz.isAssignableFrom(key))
 				{
 					Map newMap = new HashMap();
 					newMap.put(clazz, dialogInterface);
 					DialogPanelFactory.knownActorObjects.add(i, newMap);
 					added = true;
 					break;
 				}
 			}
 			if (added)
 			{
 				return true;
 			}
 		}
 
 		// it's a base class, add the factory
 		if (!added)
 		{
 			Map newMap = new HashMap();
 			newMap.put(clazz, dialogInterface);
 			DialogPanelFactory.knownActorObjects.add(0, newMap);
 			return true;
 		}
 		return false;
 	}
 
 	/***
 	 * Method createPanel creates a panel
 	 * 
 	 * @param dialogInterface the interface panel
 	 * @param object the object
 	 * @return returns an initialized panel
 	 */
 	private static JTabbedPane createPanel(
 			final DialogInterface dialogInterface, final Object object)
 	{
 
 		// set the background of the tabbed pane tabs (why do we need this code
 		// --> stupid SWING)
 		UIManager.put("TabbedPane.selected", Color.WHITE);
 
 		// initialize panel
 		JTabbedPane tabbedPane = new JTabbedPane(SwingConstants.TOP,
 				JTabbedPane.SCROLL_TAB_LAYOUT);
 		tabbedPane.setFocusable(true);
 		tabbedPane.setBackground(Color.WHITE);
 		tabbedPane.setPreferredSize(new Dimension(400, 200));
 
 		// add the panels
 		for (int i = 0; i < dialogInterface.getPanelClassNames().length; i++)
 		{
 			AbstractPanel abstractPanel = null;
 			String abstractPanelClassName = dialogInterface
 					.getPanelClassNames()[i];
 			try
 			{
 				Class abstractPanelClass = Class
 						.forName(abstractPanelClassName);
 				Constructor constructor = null;
 				try
 				{
 					constructor = abstractPanelClass
 							.getConstructor(new Class[]{Object.class});
 					abstractPanel = (AbstractPanel) constructor
 							.newInstance(new Object[]{object});
 				} catch (Exception exception)
 				{
 					// we could not find a suitable constructor
 					// let's try with the simulator as an extra argument
 					constructor = abstractPanelClass
 							.getConstructor(new Class[]{Object.class,
 									SimulatorInterface.class});
 					abstractPanel = (AbstractPanel) constructor
 							.newInstance(new Object[]{object,
 									DialogPanelFactory.simulator});
 				}
 				tabbedPane.add(abstractPanel.getName(), abstractPanel);
 
 			} catch (Exception exception)
 			{
 				Logger.warning(DialogPanelFactory.class, "createPanel",
 						"could not load " + abstractPanelClassName);
 				Logger.warning(DialogPanelFactory.class, "createPanel",
 						exception);
 			}
 		}
 		return tabbedPane;
 	}
 }