/*
    * Copyright (c) 2003-2008 by Cosylab d. d.
    *
    * This file is part of CosyBeans.
    *
    * CosyBeans 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.
   *
   * CosyBeans 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 CosyBeans.  If not, see <http://www.gnu.org/licenses/>.
   */
  
  package com.cosylab.application;
  
  import java.util.ArrayList;
  import java.util.HashSet;
  
  import com.cosylab.util.ObjectList;
  
  
  /**
   * Deafultimplementation of a <code>PlugInManager</code> interface.
   *
   * @author Igor Kriznar (<a
   *         href="mailto:igor.kriznar@cosylab.com">igor.kriznar&x40;cosylab.com</a>)
   * @version $$id$$
   */
  public class DefaultPlugInManager implements PlugInManager
  {
  	private String name= "DefaultPlugInManager";
  	private ApplicationPanel parent;
  	private boolean destroyed = false;
  	private ArrayList<PlugIn> plugins = new ArrayList<PlugIn>();
  	private HashSet<Class> cyclicPlugIn = new HashSet<Class>();
  	private ObjectList listeners = new ObjectList(PlugInListener.class);
  
  	/**
  	 * A default constructor for the plug-in manager.
  	 */
  	public DefaultPlugInManager()
  	{
  	}
  
  	/**
  	 * Returns the parent of this manager.
  	 *
  	 * @return the logical parent of this
  	 */
  	public ApplicationPanel getOwnerPanel()
  	{
  		return parent;
  	}
  
  	/**
  	 * Returns <code>true</code> iff this panel has been destroyed.
  	 *
  	 * @return boolean <code>true</code> if destroyed
  	 */
  	public final synchronized boolean isDestroyed()
  	{
  		return destroyed;
  	}
  
  	/**
  	 * Destroys this cosy panel. If already destroyed, this method returns NOP.
  	 * If plugin has visual component, first is from parent removed plugins
  	 * visual component, tha is plugin destroyed.
  	 * 
  	 * <p>
  	 * All plug-ins are destroyed before managers <code>destroyed</code> flag
  	 * is set to <code>true</code> and destruction completes.
  	 * </p>
  	 */
  	public synchronized final void destroy()
  	{
  		if (destroyed) {
  			return;
  		}
  
  		PlugIn[] pl = getPlugIns();
  
  		for (int i = 0; i < pl.length; i++) {
  			try {
  				if (pl[i] instanceof VisiblePlugIn) {
  					getOwnerPanel().removePlugInGUI((VisiblePlugIn)pl[i]);
  				}
  			} catch (Exception e) {
  				// notify
  			}
  
  			try {
  				pl[i].destroy();
 			} catch (Exception e) {
 				// notify
 			}
 			plugins.clear();
 		}
 
 		destroyed = true;
 	}
 
 	/**
 	 * Installs a new plugin. Checks if the <code>plugType</code> parameter is
 	 * valid, otherwise a <code>PlugInException</code> is thrown; checks if
 	 * the state of this object is valid;  checks if the cyclic installation
 	 * is occuring; checks if the plug has already been  installed. If all
 	 * these checks are passed, a new instance of the plugin is created, added
 	 * as a child of this cosy panel, and the <code>installPlugIn</code>
 	 * method of the plugin is invoked. If it completes successfully, the cosy
 	 * listeners are notified about the  new plugin. If it fails, the plugin
 	 * is removed from the cosy component children of this panel.
 	 *
 	 * @param plugType the class representing the plug, which must implement
 	 *        <code>PlugIn</code> interface
 	 *
 	 * @exception PlugInException if the plug installation fails
 	 * @throws NullPointerException if input is null
 	 * @throws IllegalStateException if no parent is set
 	 *
 	 * @see PlugInManager#installPlugIn(Class)
 	 */
 	public final synchronized void installPlugIn(Class plugType)
 		throws PlugInException
 	{
 		if (plugType == null) {
 			throw new NullPointerException("plugType");
 		}
 
 		if (isDestroyed()) {
 			return;
 		}
 
 		if (parent == null) {
 			throw new IllegalStateException("parent == null");
 		}
 
 		// check plug type
 		if (!PlugIn.class.isAssignableFrom(plugType)) {
 			throw new PlugInException(this,
 			    "Class '" + plugType.getName() + "' does not implement '"
 			    + PlugIn.class.getName() + "'.", plugType, null);
 		}
 
 		// check if already installed
 		if (getPlugIn(plugType) != null) {
 			return;
 		}
 
 		// check cyclic resolver
 		if (cyclicPlugIn.contains(plugType)) {
 			throw new PlugInException(this,
 			    "Cyclic plugin dependency: cannot instantiate without causing endless loop",
 			    plugType, null);
 		}
 
 		cyclicPlugIn.add(plugType);
 
 		// instantiate plug
 		PlugIn plugIn = null;
 
 		try {
 			plugIn = (PlugIn)plugType.newInstance();
 		} catch (Exception e) {
 			throw new PlugInException(this,
 			    "Could not invoke the plugin constructor.", plugType, e);
 		}
 
 		// add to this container
 		plugins.add(plugIn);
 
 		// initialize plug
 		try {
 			plugIn.installPlugIn(this);
 		} catch (Exception e) {
 			// remove from the container
 			plugins.remove(plugIn);
 			throw new PlugInException(this,
 			    "Exception while installing the plugin", plugType, e);
 		} finally {
 			// remove from cyclic resolution list 
 			cyclicPlugIn.remove(plugType);
 		}
 
 		// notify listeners
 		PlugInListener[] l = (PlugInListener[])listeners.toArray();
 		PlugInEvent event = new PlugInEvent(this, plugIn);
 
 		for (int i = 0; i < l.length; i++) {
 			try {
 				l[i].plugInInstalled(event);
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	/**
 	 * Returns all plugins managed by this cosy component.
 	 *
 	 * @return PlugIn[] a list of plug ins
 	 *
 	 * @see PlugInManager#getPlugIns()
 	 */
 	public synchronized PlugIn[] getPlugIns()
 	{
 		return plugins.toArray(new PlugIn[plugins.size()]);
 	}
 
 	/**
 	 * Returns a plugin with a given type. Since plugins are installed by their
 	 * type and installations with the same type are not allowed, the
 	 * designation by type is unique.
 	 *
 	 * @param plugType the type of the plug to look up
 	 *
 	 * @return PlugIn the plugin instance of <code>null</code> if no plugin
 	 *         with the specified type was found
 	 *
 	 * @throws NullPointerException if input  is null
 	 *
 	 * @see PlugInManager#getPlugIn(Class)
 	 */
 	public PlugIn getPlugIn(Class plugType)
 	{
 		if (plugType == null) {
 			throw new NullPointerException("plugType");
 		}
 
 		PlugIn[] array = getPlugIns();
 
 		for (int i = 0; i < array.length; i++) {
 			if (array[i].getClass().equals(plugType)) {
 				return array[i];
 			}
 		}
 
 		return null;
 	}
 
 	/**
 	 * Adds a plugin listener.
 	 *
 	 * @param l a listener object
 	 *
 	 * @see PlugInManager#addPlugInListener(PlugInListener)
 	 */
 	public void addPlugInListener(PlugInListener l)
 	{
 		listeners.add(l);
 	}
 
 	/**
 	 * Removes a plugin listener.
 	 *
 	 * @param l a listener object
 	 *
 	 * @see PlugInManager#removePlugInListener(PlugInListener)
 	 */
 	public void removePlugInListener(PlugInListener l)
 	{
 		listeners.remove(l);
 	}
 
 	/**
 	 * Returns a list of all plugin listeners, as required by Java 1.4 Beans
 	 * specs.
 	 *
 	 * @return PlugInListener[] an array of listeners
 	 *
 	 * @see PlugInManager#getPlugInListeners()
 	 */
 	public PlugInListener[] getPlugInListeners()
 	{
 		return (PlugInListener[])listeners.toArray();
 	}
 
 	/**
 	 * Removes plugin from meneger. First removes plugin visual component from
 	 * parent, then calls destroy() and then sets parent to null.
 	 *
 	 * @see com.cosylab.gui.core.PlugInManager#removePlugIn(java.lang.Class)
 	 */
 	public void removePlugIn(Class plugType)
 	{
 		if (plugType == null) {
 			throw new NullPointerException("plugType");
 		}
 
 		if (isDestroyed()) {
 			return;
 		}
 
 		if (parent == null) {
 			throw new IllegalStateException("parent == null");
 		}
 
 		PlugIn plugIn = getPlugIn(plugType);
 
 		if (plugIn == null) {
 			return;
 		}
 
 		plugins.remove(plugIn);
 
 		// remove plug
 		try {
 			if (plugIn instanceof VisiblePlugIn) {
 				getOwnerPanel().removePlugInGUI((VisiblePlugIn)plugIn);
 			}
 
 			plugIn.destroy();
 		} catch (Exception e) {
 			//  we should not throw further
 			e.printStackTrace();
 		}
 
 		// notify listeners
 		PlugInListener[] l = (PlugInListener[])listeners.toArray();
 		PlugInEvent event = new PlugInEvent(this, plugIn);
 
 		for (int i = 0; i < l.length; i++) {
 			try {
 				l[i].plugInRemoved(event);
 			} catch (Exception e) {
 				e.printStackTrace();
 			}
 		}
 	}
 
 	/**
 	 * Sets logical parent to this manager.
 	 *
 	 * @see com.cosylab.gui.core.CosyComponent#setCosyPanelParent(com.cosylab.gui.core.CosyApplicationPanel)
 	 */
 	public void setOwnerPanel(ApplicationPanel panel)
 	{
 		this.parent = panel;
 	}
 
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.core.CosyComponent#getName()
 	 */
 	public String getName()
 	{
 		return name;
 	}
 	/* (non-Javadoc)
 	 * @see com.cosylab.gui.core.PlugInManager#acquirePlugIn(java.lang.Class)
 	 */
 	public PlugIn acquirePlugIn(Class plugType) throws PlugInException {
 		PlugIn pl= getPlugIn(plugType);
 		if (pl==null) installPlugIn(plugType);
 		return getPlugIn(plugType);
 	}
 
 }
 
 /* __oOo__ */