/*
 *   This program 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.
 *
 *   This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 *    PluginManager.java
 *    Copyright (C) 2011-2012 University of Waikato, Hamilton, New Zealand
 *
 */

package weka.gui.beans;

import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

/**
 * Class that manages a global map of plugins. The knowledge flow uses this to
 * manage plugins other than step components and perspectives. Is general
 * purpose, so can be used by other Weka components. Provides static methods for
 * registering and instantiating plugins.
 * 
 * @author Mark Hall (mhall{[at]}pentaho{[dot]}com)
 * @version $Revision$
 * @deprecated Use weka.core.PluginManager instead
 */
@Deprecated
public class PluginManager {

  /**
   * Add the supplied list of fully qualified class names to the disabled list
   * 
   * @param classnames a list of class names to add
   */
  public static synchronized void addToDisabledList(List<String> classnames) {
    weka.core.PluginManager.addToDisabledList(classnames);
  }

  /**
   * Add the supplied fully qualified class name to the list of disabled plugins
   * 
   * @param classname the fully qualified name of a class to add
   */
  public static synchronized void addToDisabledList(String classname) {
    weka.core.PluginManager.addToDisabledList(classname);
  }

  /**
   * Remove the supplied list of fully qualified class names to the disabled
   * list
   * 
   * @param classnames a list of class names to remove
   */
  public static synchronized void
    removeFromDisabledList(List<String> classnames) {
    weka.core.PluginManager.removeFromDisabledList(classnames);
  }

  /**
   * Remove the supplied fully qualified class name from the list of disabled
   * plugins
   * 
   * @param classname the fully qualified name of a class to remove
   */
  public static synchronized void removeFromDisabledList(String classname) {
    weka.core.PluginManager.removeFromDisabledList(classname);
  }

  /**
   * Returns true if the supplied fully qualified class name is in the disabled
   * list
   * 
   * @param classname the name of the class to check
   * @return true if the supplied class name is in the disabled list
   */
  public static boolean isInDisabledList(String classname) {
    return weka.core.PluginManager.isInDisabledList(classname);
  }

  /**
   * Add all key value pairs from the supplied property file
   *
   * @param propsFile the properties file to add
   * @throws Exception if a problem occurs
   */
  public static synchronized void addFromProperties(File propsFile)
    throws Exception {
    weka.core.PluginManager.addFromProperties(propsFile);
  }

  /**
   * Add all key value pairs from the supplied property file
   *
   * @param propsFile the properties file to add
   * @param maintainInsertionOrder true if the order of insertion of
   *          implementations is to be preserved (rather than sorted order)
   * @throws Exception if a problem occurs
   */
  public static synchronized void addFromProperties(File propsFile,
    boolean maintainInsertionOrder) throws Exception {
    weka.core.PluginManager
      .addFromProperties(propsFile, maintainInsertionOrder);
  }

  /**
   * Add all key value pairs from the supplied properties stream
   *
   * @param propsStream an input stream to a properties file
   * @throws Exception if a problem occurs
   */
  public static synchronized void addFromProperties(InputStream propsStream)
    throws Exception {
    weka.core.PluginManager.addFromProperties(propsStream);
  }

  /**
   * Add all key value pairs from the supplied properties stream
   *
   * @param propsStream an input stream to a properties file
   * @param maintainInsertionOrder true if the order of insertion of
   *          implementations is to be preserved (rather than sorted order)
   * @throws Exception if a problem occurs
   */
  public static synchronized void addFromProperties(InputStream propsStream,
    boolean maintainInsertionOrder) throws Exception {
    weka.core.PluginManager.addFromProperties(propsStream,
      maintainInsertionOrder);
  }

  /**
   * Add all key value pairs from the supplied properties object
   *
   * @param props a Properties object
   * @throws Exception if a problem occurs
   */
  public static synchronized void addFromProperties(Properties props)
    throws Exception {
    weka.core.PluginManager.addFromProperties(props);
  }

  /**
   * Add all key value pairs from the supplied properties object
   *
   * @param props a Properties object
   * @param maintainInsertionOrder true if the order of insertion of
   *          implementations is to be preserved (rather than sorted order)
   * @throws Exception if a problem occurs
   */
  public static synchronized void addFromProperties(Properties props,
    boolean maintainInsertionOrder) throws Exception {
    weka.core.PluginManager.addFromProperties(props, maintainInsertionOrder);
  }

  /**
   * Add a resource.
   * 
   * @param resourceGroupID the ID of the group under which the resource should
   *          be stored
   * @param resourceDescription the description/ID of the resource
   * @param resourcePath the path to the resource
   */
  public static synchronized void addPluginResource(String resourceGroupID,
    String resourceDescription, String resourcePath) {
    weka.core.PluginManager.addPlugin(resourceGroupID, resourceDescription,
      resourcePath);
  }

  /**
   * Get an input stream for a named resource under a given resource group ID.
   * 
   * @param resourceGroupID the group ID that the resource falls under
   * @param resourceDescription the description/ID of the resource
   * @return an InputStream for the resource
   * @throws IOException if the group ID or resource description/ID are not
   *           known to the PluginManager, or a problem occurs while trying to
   *           open an input stream
   */
  public static InputStream getPluginResourceAsStream(String resourceGroupID,
    String resourceDescription) throws IOException {
    return weka.core.PluginManager.getPluginResourceAsStream(resourceGroupID,
      resourceDescription);
  }

  /**
   * Get the number of resources available under a given resource group ID.
   *
   * @param resourceGroupID the group ID of the resources
   * @return the number of resources registered under the supplied group ID
   */
  public static int numResourcesForWithGroupID(String resourceGroupID) {
    return weka.core.PluginManager.numResourcesForWithGroupID(resourceGroupID);
  }

  /**
   * Get a map of resources (description,path) registered under a given resource
   * group ID.
   *
   * @param resourceGroupID the group ID of the resources to get
   * @return a map of resources registered under the supplied group ID, or null
   *         if the resourceGroupID is not known to the plugin manager
   */
  public static Map<String, String> getResourcesWithGroupID(
    String resourceGroupID) {
    return weka.core.PluginManager.getResourcesWithGroupID(resourceGroupID);
  }

  /**
   * Get a set of names of plugins that implement the supplied interface.
   * 
   * @param interfaceName the fully qualified name of the interface to list
   *          plugins for
   * 
   * @return a set of names of plugins
   */
  public static Set<String> getPluginNamesOfType(String interfaceName) {
    return weka.core.PluginManager.getPluginNamesOfType(interfaceName);
  }

  /**
   * Add a plugin.
   *
   * @param interfaceName the fully qualified interface name that the plugin
   *          implements
   *
   * @param name the name/short description of the plugin
   * @param concreteType the fully qualified class name of the actual concrete
   *          implementation
   */
  public static void addPlugin(String interfaceName, String name,
    String concreteType) {
    weka.core.PluginManager.addPlugin(interfaceName, name, concreteType);
  }

  /**
   * Add a plugin.
   *
   * @param interfaceName the fully qualified interface name that the plugin
   *          implements
   *
   * @param name the name/short description of the plugin
   * @param concreteType the fully qualified class name of the actual concrete
   *          implementation
   * @param maintainInsertionOrder true if the order of insertion of
   *          implementations is to be preserved (rather than sorted order)
   */
  public static void addPlugin(String interfaceName, String name,
    String concreteType, boolean maintainInsertionOrder) {
    weka.core.PluginManager.addPlugin(interfaceName, name, concreteType,
      maintainInsertionOrder);
  }

  /**
   * Remove plugins of a specific type.
   * 
   * @param interfaceName the fully qualified interface name that the plugins to
   *          be remove implement
   * @param names a list of named plugins to remove
   */
  public static void removePlugins(String interfaceName, List<String> names) {
    for (String name : names) {
      weka.core.PluginManager.removePlugins(interfaceName, names);
    }
  }

  /**
   * Remove a plugin.
   * 
   * @param interfaceName the fully qualified interface name that the plugin
   *          implements
   * 
   * @param name the name/short description of the plugin
   */
  public static void removePlugin(String interfaceName, String name) {
    weka.core.PluginManager.removePlugin(interfaceName, name);
  }

  /**
   * Get an instance of a concrete implementation of a plugin type
   * 
   * @param interfaceType the fully qualified interface name of the plugin type
   * @param name the name/short description of the plugin to get
   * @return the concrete plugin or null if the plugin is disabled
   * @throws Exception if the plugin can't be found or instantiated
   */
  public static Object getPluginInstance(String interfaceType, String name)
    throws Exception {
    return weka.core.PluginManager.getPluginInstance(interfaceType, name);
  }
}
