/*
   Copyright (C) 2000 - 2007 Grid Systems, S.A.
   
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2, as
   published by the Free Software Foundation.
   
   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, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
  package com.gridsystems.innergrid.api;
  
  import java.io.InputStream;
  import java.io.Serializable;
  import java.lang.reflect.Constructor;
  import java.net.URL;
  import java.rmi.Remote;
  import java.util.Comparator;
  import java.util.Enumeration;
  import java.util.Map;
  import java.util.Properties;
  import java.util.TreeMap;
  
  import com.gridsystems.innergrid.kernel.KernelException;
  
  /**
   * Helper class able to create API instances, through {@link #newApi newApi}.
   *
   * @author Xmas
   * @version 1.0
   */
  public final class ApiFactory {
  
    /**
     * Port for the connection used during discovery.
     */
    private static final int DUMMY_DEFAULT_PORT = 1;
  
    /**
     * API internal cache.
     */
    private static Map<Class, Api> apis = new TreeMap<Class, Api>(new ClassComparator());
  
    /**
     * Interface internal cache.
     */
    private static Map<Class, Class> interfaces
      = new TreeMap<Class, Class>(new ClassComparator());
  
    /**
     * Utility class: no need to instantiate it.
     */
    private ApiFactory() { }
  
    /*
     * Loading all ApiProviders in the classpath. Discovery is performed by reading
     * all resources with name "com/gridsystems/innergrid/api/api.providers" in the
     * classpath.
     */
    static {
      String apiname = "com/gridsystems/innergrid/api/api.providers";
  
      //Location of the description files of Api providers
  
      Enumeration enumeration = null;
      try {
        ClassLoader cl = Thread.currentThread().getContextClassLoader();
        enumeration = cl.getResources(apiname);
      } catch (Exception ex) {
        System.err.println("ApiFactory::static() -> Error loading API.");
        enumeration = null;
      }
  
      Connection conn = null;
      try {
        Credentials cred = new UsernameTokenCredentials("", "");
        conn = new DirectConnection("localhost", DUMMY_DEFAULT_PORT, true, cred);
      } catch (Exception e) { }
  
      while (enumeration.hasMoreElements()) {
        URL resource = (URL)enumeration.nextElement();
        parseResource(resource, conn);
      }
    };
  
    /**
     * Parsing a single resource and registering all declared API providers.
     *
     * @param resource the resource to parse
     * @param c        the connection to use for instantiation
     */
    private static void parseResource(URL resource, Connection c) {
      try {
       InputStream is = resource.openStream();
 
       Properties props = new Properties();
       props.load(is);
 
       Enumeration e = props.keys();
 
       while (e.hasMoreElements()) {
         String key = (String)e.nextElement();
         String value = props.getProperty(key);
         parseResourceKeyValue(key, value, c);
       }
     } catch (Exception ex) { }
   }
 
   /**
    * Parsing a single key-value pair in a resource, and if it declares a valid API
    * provider, it registers it.
    *
    * @param key   the key
    * @param value the value
    * @param c     the connection to use for instantiation
    */
   private static void parseResourceKeyValue(String key, String value, Connection c) {
     String implName = key;
     String ifaceName = value;
     boolean isRemote = true;
 
     int pos = value.indexOf(",");
     if (pos != -1) {
       ifaceName = value.substring(0, pos);
       isRemote = value.substring(pos + 1, value.length()).trim().equals("remote");
     }
 
     // Loading implementation Class
     Class< ? > impl;
     try {
       impl = Class.forName(implName);
       Constructor cons = impl.getConstructor(new Class[] {Connection.class});
       cons.newInstance(new Object[] {c});
     } catch (ClassNotFoundException ex) {
       System.err.println("Cannot find " + implName + " implementation class");
       return;
     } catch (Exception e) {
       System.err.println("Cannot find constructor with Connection "
                          + "parameter in " + implName + " class");
       return;
     }
 
     //  Loading interface Class
     Class iface;
     try {
       iface = Class.forName(ifaceName);
     } catch (Exception ex) {
       System.err.println("Cannot find " + ifaceName + " interface");
       return;
     }
 
     // Adding
     try {
       addApi(iface, impl, isRemote);
     } catch (Exception ex) {
       System.err.println("Cannot add api to internal list");
     }
   }
 
   /**
    * Compares two class names lexicographically, not taking into account the case.
    *
    * @author Xmas
    * @version 1.0
    */
   private static class ClassComparator implements Comparator<Class>, Serializable {
 
     /**
      * Serial Version UID.
      */
     private static final long serialVersionUID = 1234523452345L;
 
     /**
      * Default constructor.
      */
     public ClassComparator() { }
 
     /**
      * {@inheritDoc}
      */
     public int compare(Class c1, Class c2)  {
       String s1 = c1 == null ? "null" : c1.getName();
       String s2 = c2 == null ? "null" : c2.getName();
 
       return s1.compareToIgnoreCase(s2);
     }
   }
 
   /**
    * Api Wrapper.
    */
   private static class Api {
 
     /**
      * The remote interface class.
      */
     public Class iface = null;
 
     /**
      * The implementation Class.
      */
     public Class impl = null;
 
     /**
      * Remote flag: <code>true</code> if the implementation is from a remote stub.
      */
     public boolean isRemote = true;
 
     /**
      * Creates a new instance.
      *
      * @param iface the remote interface class
      * @param impl the implementation class
      * @param isRemote a boolean set to <code>true</code> if the implementation is
      *        from a remote stub
      */
     public Api(Class iface, Class impl, boolean isRemote) {
       this.iface = iface;
       this.impl = impl;
       this.isRemote = isRemote;
     }
   }
 
   /**
    * Adds an Api instance to the list.
    *
    * @param interf the remote interface class
    * @param impl the implementation class
    * @param isremote a boolean set to <code>true</code> if the implementation is remote,
    *        <code>false</code> if it is local
    */
   private static void addApi(Class interf, Class impl, boolean isremote) {
     if (interf == null || impl == null) {
       return;
     }
 
     Api newapi = new Api(interf, impl, isremote);
     apis.put(impl, newapi);
 
     Class oldimpl = (Class)interfaces.get(interf);
     if (oldimpl != null) {
       Api oldapi = (Api)apis.get(oldimpl);
       if (oldapi.isRemote && !isremote) {
         return;
       }
     }
     interfaces.put(interf, impl);
   }
 
   /**
    * Gets a list of all APIs.
    *
    * @return returns an array of Apis with the list of all registered API wrappers
    */
   public static Api[] getAllApis() {
     return (Api[])apis.values().toArray(new Api[0]);
   }
 
   /**
    * Gets an instance of an API for the specified remote interface and connection.
    *
    * @param iface the interface that the returned instance must implement
    * @param con the connection to use to create the Api
    * @return an instance of the specified API implementation
    * @param <T> Remote Class.
    *
    * @throws KernelException <code>CLT011</code> if the connection is null
    * @throws KernelException <code>CLT015</code> if the interface is null, if is not
    *                         registered, or if instantiation fails
    */
   @SuppressWarnings("unchecked")
   public static <T extends Remote> T newApi(Class<T> iface, Connection con)
     throws KernelException  {
 
     if (con == null) { // Connection can not be null
       throw new CKernelException("CLT011");
     }
     if (iface == null) {   // Implementation not found for {0} interface
       throw new CKernelException("CLT015", new String[] { "null" });
     }
     Class impl = (Class)interfaces.get(iface);
     if (impl == null) {
       throw new CKernelException("CLT015", new String[] { iface.getName() });
     }
     T instance;
     try {
       Constructor cons = impl.getConstructor(new Class[] { Connection.class });
       instance = (T)cons.newInstance(new Object[] { con });
     } catch (Exception ex) {
       throw new CKernelException("CLT015", new String[] { iface.getName() });
     }
     return instance;
   }
 
 }