/*
   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.File;
  import java.io.InputStream;
  import java.lang.reflect.Proxy;
  import java.net.URL;
  import java.rmi.Remote;
  import java.util.Hashtable;
  import java.util.Map;
  import java.util.concurrent.ConcurrentHashMap;
  import java.util.concurrent.ConcurrentMap;
  
  import javax.xml.namespace.QName;
  import javax.xml.rpc.ServiceException;
  import javax.xml.rpc.Stub;
  import javax.xml.rpc.encoding.DeserializerFactory;
  import javax.xml.rpc.encoding.SerializerFactory;
  import javax.xml.rpc.encoding.TypeMapping;
  
  import com.gridsystems.utils.FileUtils;
  
  import org.apache.axis.MessageContext;
  import org.apache.axis.WSDDEngineConfiguration;
  import org.apache.axis.client.AxisClient;
  import org.apache.axis.client.Call;
  import org.apache.axis.client.Service;
  import org.apache.axis.configuration.FileProvider;
  import org.apache.axis.deployment.wsdd.WSDDDeployment;
  import org.apache.axis.deployment.wsdd.WSDDDocument;
  import org.apache.axis.encoding.TypeMappingRegistry;
  import org.apache.axis.encoding.ser.BeanDeserializerFactory;
  import org.apache.axis.encoding.ser.BeanSerializerFactory;
  import org.apache.axis.handlers.soap.SOAPService;
  import org.apache.axis.transport.http.HTTPConstants;
  import org.apache.axis.utils.XMLUtils;
  import org.apache.commons.discovery.ResourceNameIterator;
  import org.apache.commons.discovery.resource.ClassLoaders;
  import org.apache.commons.discovery.resource.names.DiscoverServiceNames;
  import org.apache.commons.logging.Log;
  import org.apache.commons.logging.LogFactory;
  
  /**
   * ApiClientFactory type.
   *
   * @author Rodrigo Ruiz
   */
  public abstract class ClientApiFactory extends HTTPConstants {
  
    /**
     * Client API registry entry.
     */
    public static class ApiEntry {
      /** Factory for this API stubs. */
      public ClientApiFactory factory;
  
      /** API interface. */
      public Class< ? > iface;
  
      /** API WSDL. */
      public URL wsdl;
  
      /** WSDD. */
      public URL wsdd;
  
      /** API Service name in WSDL. */
      public QName serviceName;
  
      /** API Port name in WSDL. */
      public QName portName;
    }
  
    /**
     * A Service subclass that uses a singleton EngineConfiguration and
     * AxisClient.
     */
    private static class FuraService extends Service {
      /**
       * <code>serialVersionUID</code> attribute.
       */
      private static final long serialVersionUID = 1L;
  
      /**
       * Singleton engine configuration.
      */
     private static final WSDDEngineConfiguration CONFIG;
 
     /**
      * Singleton client engine.
      */
     private static final AxisClient ENGINE;
 
     static {
       // Fura client APIs use their own configuration
       CONFIG = new FileProvider("fura-client-config.wsdd");
       ENGINE = new AxisClient(CONFIG);
     }
 
     /**
      * Creates a new instance.
      *
      * @param wsdl          The URL to the Service WSDL
      * @param serviceName   The Service name in the WSDL
      * @throws ServiceException If an error occurs
      */
     public FuraService(URL wsdl, QName serviceName) throws ServiceException {
       super(wsdl, serviceName);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override protected AxisClient getAxisClient() {
       return ENGINE;
     }
   }
 
   /**
    * Class logger.
    */
   private static final Log LOG = LogFactory.getLog(ClientApiFactory.class);
 
   /**
    * Initial capacity for the factory map.
    */
   private static final int INITIAL_CAPACITY = 15;
 
   /**
    * Load factor for the factory map.
    */
   private static final float LOAD_FACTOR = 0.75f;
 
   /**
    * Concurrency level for the factory map.
    */
   private static final int CONCURRENCY_LEVEL = 5;
 
   /**
    * Keeps the time at which this class has been loaded, so WSDL files cached
    * before this moment can be discarded.
    */
   private static final long WSDL_CACHE_STARTUP = System.currentTimeMillis();
 
   /**
    * WSDL Parser map.
    */
   private static final ConcurrentMap<Class<?>, QName> API_NAMES;
 
   /**
    * WSDL Parser map.
    */
   private static final ConcurrentMap<QName, ApiEntry> API_ENTRIES;
 
   static {
     API_NAMES = new ConcurrentHashMap<Class<?>, QName>(
       INITIAL_CAPACITY, LOAD_FACTOR, CONCURRENCY_LEVEL);
 
     API_ENTRIES = new ConcurrentHashMap<QName, ApiEntry>(
       INITIAL_CAPACITY, LOAD_FACTOR, CONCURRENCY_LEVEL);
 
     // Discover factories
 
     final String spi = ClientApiFactory.class.getName();
     LOG.info("Discovering API factories for '" + spi + "'");
     final ClassLoaders loaders = new ClassLoaders();
     loaders.put(Thread.currentThread().getContextClassLoader());
     final DiscoverServiceNames discover = new DiscoverServiceNames(loaders);
     ResourceNameIterator it = discover.findResourceNames(spi);
     while (it.hasNext()) {
       String factoryName = it.nextResourceName();
       try {
         Class<?> factoryClass = Class.forName(factoryName);
         if (ClientApiFactory.class.isAssignableFrom(factoryClass)) {
           // Creating a new instance will trigger the registry process
           LOG.info("Registering " + factoryName);
           ((ClientApiFactory)factoryClass.newInstance()).registerApis();
         }
       } catch (Exception e) {
         LOG.warn("Could not register factory '" + factoryName + "'", e);
       }
     }
   }
 
   /**
    * Registers this instance into the FACTORIES map.
    *
    * @param api API entry descriptor
    */
   public static void register(ApiEntry api) {
     API_NAMES.putIfAbsent(api.iface, api.serviceName);
     API_ENTRIES.putIfAbsent(api.serviceName, api);
 
     if (api.wsdd != null && FuraService.CONFIG != null) {
       LOG.debug("Registering WSDD '" + api.wsdd + "'");
       InputStream is = null;
       try {
         is = api.wsdd.openStream();
         WSDDDeployment deployment = FuraService.CONFIG.getDeployment();
         WSDDDocument doc = new WSDDDocument(XMLUtils.newDocument(is));
         doc.deploy(deployment);
 
         FuraService.ENGINE.refreshGlobalOptions();
       } catch (Exception e) {
         LOG.warn("Could not register API '" + api.iface.getName() + "'", e);
       } finally {
         if (is != null) {
           try {
             is.close();
           } catch (Exception e) { }
         }
       }
     }
   }
 
   /**
    * Creates a new instance.
    */
   protected ClientApiFactory() {
     //registerApis();
   }
 
   /**
    * Hook for registering the APIs this factory is responsible for.
    */
   protected abstract void registerApis();
 
   /**
    * Creates a new instance using a dynamic proxy.
    *
    * @param entry  The API descriptor
    * @param con    Used to configure target endpoint and authentication
    * @return       An implementation of "iface"
    * @throws ServiceException If an error occurs
    */
   protected Remote newInstance(ApiEntry entry, Connection con) throws ServiceException {
     ClassLoader loader = Thread.currentThread().getContextClassLoader();
     Class< ? >[] ifaces = { entry.iface, javax.xml.rpc.Stub.class };
 
     Stub port = (Stub)getPort(entry, con);
 
     return (Remote)Proxy.newProxyInstance(loader, ifaces,
       new ClientApiProxy(entry.iface, port, con));
   }
 
   /**
    * Creates a stub instance for the given API.
    *
    * @param entry The API descriptor
    * @param con    Used to configure target endpoint and authentication
    * @return The stub
    * @throws ServiceException If an error occurs
    */
   @SuppressWarnings("unchecked")
   public final Remote getPort(ApiEntry entry, Connection con) throws ServiceException {
     fixWsdl(entry, con);
 
     Service service = new FuraService(entry.wsdl, entry.serviceName);
     Remote remote = service.getPort(entry.iface);
 
     // Initialise the stub
     Stub stub = (Stub)remote;
     Map headers = (Map)stub._getProperty(REQUEST_HEADERS);
     if (headers == null) {
       headers = new Hashtable();
       stub._setProperty(REQUEST_HEADERS, headers);
     }
 
     return (Remote)stub;
   }
 
   /**
    * Downloads a service WSDL descriptor from a remote server into the user temp
    * folder, and updates the specified entry.
    *
    * @param entry The API descriptor
    * @param con    Used to configure target endpoint and authentication
    */
   private void fixWsdl(ApiEntry entry, Connection con) {
     if (entry.wsdl == null && con != null && entry.serviceName != null) {
       String tempDir = System.getProperty("java.io.tmpdir");
       File temp = new File(tempDir, "ClientApiFactory");
       temp.mkdirs();
 
       String ns = entry.serviceName.getNamespaceURI();
       String name = entry.serviceName.getLocalPart();
       ns = ns.replaceAll("[:/]+", "_");
       String wsdlName = ns + "_" + name + ".wsdl";
       File f = new File(temp, wsdlName);
 
       if (f.isFile() && WSDL_CACHE_STARTUP < f.lastModified()) {
         try {
           entry.wsdl = f.toURI().toURL();
         } catch (Exception e) {
           throw new RuntimeException("Could not build URL to service WSDL", e);
         }
       } else {
         try {
           StringBuffer sbUrl = new StringBuffer();
           sbUrl.append((con.isSecured()) ? "https://" : "http://");
           sbUrl.append(con.getHost());
           sbUrl.append(':');
           sbUrl.append(con.getPort());
           sbUrl.append("/kernel/api/");
           sbUrl.append(entry.portName.getLocalPart());
           sbUrl.append("?wsdl");
           URL url = new URL(sbUrl.toString());
           FileUtils.createFile(url.openStream(), f);
 
           entry.wsdl = f.toURI().toURL();
         } catch (Exception e) {
           f.delete();
           e.printStackTrace();
           throw new RuntimeException(entry.serviceName + " WSDL download failed", e);
         }
       }
     }
   }
 
   /**
    * Creates a new API stub instance.
    *
    * @param <T>      The stub type
    * @param iface    The stub interface class
    * @param con      The connection
    * @return A stub
    * @throws Exception If an error occurs
    */
   public static <T extends Remote> T newApi(Class<T> iface, Connection con)
     throws Exception {
     if (iface == null) {
       return null;
     } else {
       QName name = API_NAMES.get(iface);
       if (name == null) {
         throw new CKernelException("CLT015", iface.getName());
       } else {
         return newApi(iface, API_NAMES.get(iface), con);
       }
     }
   }
 
   /**
    * Creates a new API stub instance.
    *
    * @param <T>         Stub type
    * @param iface       Stub interface class
    * @param serviceName Service qualified name
    * @param con         Connection
    * @return A stub instance
    * @throws Exception If an error occurs
    */
   public static <T extends Remote> T newApi(Class<T> iface, QName serviceName,
     Connection con) throws Exception {
     ApiEntry entry = API_ENTRIES.get(serviceName);
 
     if (entry == null) {
       throw new CKernelException("CLT015", iface.getName());
     } else {
       return (T)entry.factory.newInstance(entry, con);
     }
   }
 
 
   /**
    * Gets the back-end engine configuration.
    *
    * @return The engine configuration
    */
   public static WSDDEngineConfiguration getConfig() {
     return FuraService.CONFIG;
   }
 
   /**
    * Gets the back-end engine.
    *
    * @return The engine
    */
   public static AxisClient getEngine() {
     return FuraService.ENGINE;
   }
 
   /**
    * Moves a type mapping defined in the "" encoding to the default encoding.
    *
    * @param svcName  The service name
    * @param javaType The java class
    * @param xmlType  The QName of the XML type
    */
   public static void fixTypeMapping(String svcName, Class<?> javaType, QName xmlType) {
     try {
       SOAPService svc = ClientApiFactory.getEngine().getService(svcName);
       TypeMappingRegistry tmr = svc.getTypeMappingRegistry();
 
       SerializerFactory sf = null;
       DeserializerFactory df = null;
 
       String[] styleURIs = tmr.getRegisteredEncodingStyleURIs();
       for (String uri : styleURIs) {
         TypeMapping tm = tmr.getTypeMapping(uri);
         sf = tm.getSerializer(javaType, xmlType);
         df = tm.getDeserializer(javaType, xmlType);
         if (sf != null && df != null) {
           break;
         }
       }
 
       if (sf == null || df == null) {
         // No serialiser found. We assume the type is a bean
         sf = new BeanSerializerFactory(javaType, xmlType);
         df = new BeanDeserializerFactory(javaType, xmlType);
       }
 
       // Register the type in all type mappings
       tmr.getDefaultTypeMapping().register(javaType, xmlType, sf, df);
       for (String uri : styleURIs) {
         TypeMapping tm = tmr.getTypeMapping(uri);
         tm.register(javaType, xmlType, sf, df);
       }
     } catch (Exception e) {
       throw new RuntimeException(e);
     }
   }
 }