/**
    * Copyright 2005-2008 the original author or authors.
    *
    * Licensed under the Gnu General Pubic License, Version 2.0 (the
    * "License"); you may not use this file except in compliance with
    * the License. You may obtain a copy of the License at
    *
    *      http://www.opensource.org/licenses/gpl-license.php
    *
   * 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.
   */
  package org.figure8.join.services.remoting.xmlrpc;
  
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.core.InvalidParameterException;
  import org.figure8.join.services.remoting.ArtifactService;
  import org.figure8.join.services.remoting.ResourceService;
  import org.figure8.join.services.remoting.ProcessControlService;
  import org.figure8.join.services.remoting.InvalidSessionException;
  import org.figure8.join.services.remoting.beans.RemoteRelease;
  import org.figure8.join.services.remoting.beans.RemoteComponent;
  import org.figure8.join.services.remoting.beans.RemoteDeliverable;
  import org.figure8.join.services.remoting.beans.RemoteDeliverableType;
  import org.figure8.join.services.remoting.beans.RemoteResourceVersion;
  import org.figure8.join.services.security.InvalidLoginException;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.beanutils.BeanUtils;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.IOException;
  import java.rmi.RemoteException;
  import java.util.List;
  import java.util.Vector;
  import java.util.Hashtable;
  /**
   * This is the default implementation of {@see XmlRcpHandler}
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.3 $
   */
  public class DefaultXmlRpcHandler implements XmlRpcHandler{
  
  // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(DefaultXmlRpcHandler.class);
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The ArtifactService implementation to dispatch requests to */
     private ArtifactService artifactService = null;
     /** The ResourceService implementation to dispatch requests to */
     private ResourceService resourceService = null;
     /** The ProcessControlService implementation to dispatch requests to */
     private ProcessControlService controlService = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of DefaultXmlRpcHandler */
     public DefaultXmlRpcHandler(){
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @param service The ArtifactService implementation to use */
     public void setArtifactService(ArtifactService service){
        this.artifactService = service;
     }
     /** @param service The ResourceService implementation to use */
     public void setResourceService(ResourceService service){
        this.resourceService = service;
     }
     /** @param service The ProcessControlService implementation to use */
     public void setProcessControlService(ProcessControlService service){
        this.controlService = service;
     }
  
  
     // Implementation of XmlRpcHandler ------------------------------------------
  
     /**
      * Authenticates a remote user onto Join application. In case of successfull
      * authentication, this method returns a token that should be used later as
      * a parameter for calling services required authorization.
      * @param username Login of user for authentication
      * @param password Password of corresponding user
      * @return An authentication token to reuse later during service call
      * @throws InvalidLoginException if user cannot be logged
      * @throws RemoteException if an exception occurs during the remote conversation
      */
     public String login(String username, String password) throws InvalidLoginException, RemoteException{
       return controlService.login(username, password);
    }
 
    /**
     * Logs out from Join application the user corresponding to the supplied token.
     * @param token An authentication token obtained with <code>login()</code> method.
     * @throws RemoteException if an exception occurs during the remote conversation
     * @return Wether this operation is successfull
     */
    public boolean logout(String token) throws RemoteException{
       controlService.logout(token);
       return true;
    }
 
    /**
     * Retrieve all the releases managed within the project.
     * @param token Authentication token provided earlier by login() method
     * @return An array representing RemoteRelease objects
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     */
    public List getReleases(String token) throws InvalidSessionException, RemoteException{
       return makeList(artifactService.getReleases(token));
    }
 
    /**
     * Retrieve all the deliverable categories (or types) managed within the project.
     * @param token Authentication token provided earlier by login() method
     * @return An array representing RemoteDeliverableType objects
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     */
    public List getDeliverableTypes(String token) throws InvalidSessionException, RemoteException{
       return makeList(artifactService.getDeliverableTypes(token));
    }
 
    /**
     * Get the deliverable categories where authenticated user can supply deliverables for.
     * @param token Authentication token provided earlier by login() method
     * @return An array representing RemoteDeliverableType objects for deliverables supplying
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     */
    public List getDeliverableTypesForDelivery(String token) throws InvalidSessionException, RemoteException{
       return makeList(artifactService.getDeliverableTypesForDelivery(token));
    }
 
    /**
     * Supply a new deliverable using the remote wrapper. This wrapper must contains
     * release and type informations. This delivery may include a File object as deliverable
     * content if deliverables from this type are not retrieved using direct VCS or SCM connection.
     * @param token Authentication token provided earlier by login() method
     * @param releaseName The unique name of Release to supply a deliverable for
     * @param typeKey The unique key of deliverable type this delivery will be bound to
     * @param versionInfo The version info (or VCS tag info) for this delivery
     * @param comments The comments on deliverable creation
     * @param content The deliverable content if not VCS deliverable
     * @throws InvalidParameterException if deliverable is already registered or parameter is missing
     * @throws DuplicateEntityException if another deliverable with same key already exists
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     * @return Wether this operation is successfull
     */
    public boolean supplyDeliverable(String token, String releaseName, String typeKey,
                                     String versionInfo, String comments, byte[] content)
            throws InvalidParameterException, DuplicateEntityException, InvalidSessionException, RemoteException{
 
       // Retrieve specified RemoteRelease.
       RemoteRelease release = null;
       RemoteRelease[] releases = artifactService.getReleases(token);
       for (int i=0; i<releases.length; i++)
          if (releases[i].getName().equals(releaseName))
             release = releases[i];
       // Retrieve specified RemoteDeliverableType.
       RemoteDeliverableType type = null;
       RemoteDeliverableType[] types = artifactService.getDeliverableTypes(token);
       for (int i=0; i<types.length; i++)
          if (types[i].getKey().equals(typeKey))
             type = types[i];
       // Build a new RemoteDeliverable.
       RemoteDeliverable deliverable = new RemoteDeliverable(versionInfo, comments, release, type);
 
       // Copy content to file if provided.
       File contentFile = null;
       if (content != null && content.length > 0){
          try{
             contentFile = File.createTempFile("join-xmlrpc", ".tmp");
             contentFile.deleteOnExit();
             new FileOutputStream(contentFile).write(content);
          }
          catch (IOException ioe){
             // Log and wrap into RemoteException.
             log.error("Exception occurs while writing delivery content on temporary file");
             log.error("Here's the errors message: " + ioe.getMessage());
             throw new RemoteException("IOException while writinn delivery content to file. Delivery is cancelled.");
          }
       }
       // Delegate request to artifact service.
       artifactService.supplyDeliverable(token, deliverable, contentFile);
       return true;
    }
 
    /**
     * Bind a component to a given assembly.
     * @param token Authentication token provided earlier by login() method
     * @param typeKey The unique key of component type this component will be bound to
     * @param versionInfo The version info for this component
     * @param size The size in bytes of this component
     * @param assemblyKey The key of assembly to bind component to
     * @throws InvalidParameterException if parameter is missing
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     * @return Wether this operation is successfull
     */
    public boolean bindComponent(String token, String typeKey, String versionInfo,
                                 long size, String assemblyKey)
            throws InvalidParameterException, InvalidSessionException, RemoteException{
       // Build intermediate RemoteComponent and delegate to service.
       RemoteComponent component = new RemoteComponent(versionInfo, size, typeKey);
       artifactService.bindComponent(token, component, assemblyKey);
       return true;
    }
 
    /**
     * Set the specified status to a specified <code>Build</code>.
     * @param token Authentication token provided earlier by login() method
     * @param statusKey Unique key idenitifer of the status to set to build
     * @param buildKey The unique key idenitifer of Build to update status
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     * @return Wether this operation is successfull
     */
    public boolean setBuildStatus(String token, String statusKey, String buildKey)
            throws InvalidSessionException, RemoteException{
       controlService.setBuildStatus(token, statusKey, buildKey);
       return true;
    }
 
    /**
     * Set the specified status to a specified <code>Assembly</code>.
     * @param token Authentication token provided earlier by login() method
     * @param statusKey Unique key idenitifer of the status to set to assembly
     * @param assemblyKey The unique key idenitifer of Assembly to update status
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     * @return Wether this operation is successfull
     */
    public boolean setAssemblyStatus(String token, String statusKey, String assemblyKey)
            throws InvalidSessionException, RemoteException{
       controlService.setAssemblyStatus(token, statusKey, assemblyKey);
       return true;
    }
 
    /**
     * Set the specified status to a specified <code>Deployment</code>.
     * @param token Authentication token provided earlier by login() method
     * @param statusKey Unique key idenitifer of the status to set to deployment
     * @param deploymentId The unique identifier of Deployment to retrieve status for
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws NumberFormatException if deploymentId does not represent a long
     * @throws RemoteException if an exception occurs during the remote conversation
     * @return Wether this operation is successfull
     */
    public boolean setDeploymentStatus(String token, String statusKey, String deploymentId)
            throws InvalidSessionException, NumberFormatException, RemoteException{
       // Cast and delegate.
       long deploymentIdL = Long.valueOf(deploymentId).longValue();
       controlService.setDeploymentStatus(token, statusKey, deploymentIdL);
       return true;
    }
 
    /**
     * Create a new resource version for a specified resource type. This operation
     * reqires a valid authentication done first and the permissions corresponding
     * to Joiner security role.
     * @param token Authentication token provided earlier by login() method
     * @param versionName The name of the resource version to create
     * @param versionDescription The description of resource version to create
     * @param resourceTypeKey The key of resource type this version applies to
     * @throws InvalidParameterException if parameter is missing
     * @throws DuplicateEntityException if another version with same name already exists
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     * @return Wether this operation is successfull
     */
    public boolean createResourceVersion(String token, String versionName,
                                         String versionDescription, String resourceTypeKey)
            throws InvalidParameterException, DuplicateEntityException, InvalidSessionException, RemoteException{
       // Build intermediate RemoteResourceVersion and delegate to service.
       RemoteResourceVersion version = new RemoteResourceVersion(versionName, versionDescription, resourceTypeKey);
       resourceService.createResourceVersion(token, version);
       return true;
    }
 
    /**
     * Update an existing resource with an existing reosurce version. Resource and
     * version are specified using their names that should be unique within Join system.
     * This operations requires a valid authentication done first and the persmissions
     * corresponding to Joiner security role.
     * @param token Authentication token provided earlier by login() method
     * @param resourceName The unique name of the resource to update
     * @param versionName The unique name of the version to update resource with
     * @throws InvalidParameterException if one of supplied parameters is invalid
     * @throws InvalidSessionException if user has no valid session on server-side
     * @throws RemoteException if an exception occurs during the remote conversation
     * @return Wether this operation is successfull
     */
    public boolean updateResource(String token, String resourceName, String versionName)
            throws InvalidParameterException, InvalidSessionException, RemoteException{
       resourceService.updateResource(token, resourceName, versionName);
       return true;
    }
 
 
    // Private ------------------------------------------------------------------
 
    /**
     * Make a Xml-Rpc array of given beans
     * @return A list that will be serialized into an {@code &lt;array&gt;}
     */
    private List makeList(Object[] beans){
       // Prepare result.
       Vector result = new Vector();
       // Browse beans and make a String or a Struct.
       for (int i=0; i<beans.length; i++){
          if (beans[i] instanceof String)
             result.add(beans[i]);
          else
             result.add(makeStructure(beans[i]));
       }
       return result;
    }
 
    /**
     * Make a Xml-Rpc structure of a given bean
     * @return A Hashtable that will be serialized into a {@code &lt;struct&gt;}
     */
    private Hashtable makeStructure(Object bean){
       try{
          // Use BeanUtils to describe the bean.
          return new Hashtable(BeanUtils.describe(bean)){
             /**
              * Do not throw NullPointerException if key or value is null.
              * Do not store the 'class' property of the given bean.
              */
             public synchronized Object put(Object key, Object value){
                if (key == null || value == null || "class".equals(key))
                   return null;
                else
                   return super.put(key, value);
             }
          };
       }
       catch (Exception e){
          // Just produce warning before returning null...
          log.warn("Exception occurs while making structure for bean: " + bean);
          return null;
       }
    }
 }