/**
    * Copyright 2005-2006 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.control.action;
  
  import org.figure8.join.control.JoinAction;
  import org.figure8.join.control.form.AssemblyForm;
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.businessobjects.commons.Status;
  import org.figure8.join.businessobjects.commons.Release;
  import org.figure8.join.businessobjects.artifact.Assembly;
  import org.figure8.join.businessobjects.artifact.Deliverable;
  import org.figure8.join.businessobjects.artifact.DeliverableType;
  import org.figure8.join.businessobjects.environment.Deployment;
  import org.figure8.join.businessfacades.artifact.ArtifactManager;
  import org.figure8.join.businessfacades.artifact.AssemblyManager;
  import org.figure8.join.businessfacades.commons.IntegrationProcessManager;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.apache.commons.beanutils.PropertyUtils;
  import org.apache.struts.action.ActionForm;
  import org.apache.struts.action.ActionForward;
  import org.apache.struts.action.ActionMapping;
  
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import java.util.List;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.ArrayList;
  /**
   * This is a Struts action for managing and viewing assemblies in Join system.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   *
   * @struts.action path="/assembly" name="assemblyForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/artifact/assemblies.jsp"
   * @struts.action-forward name="Form" path="/jsp/artifact/assemblyform.jsp"
   * @struts.action-forward name="Status" path="/jsp/forcestatus.jsp"
   * @struts.action-forward name="Assembly" path="/jsp/artifact/assembly.jsp"
   * @struts.action-forward name="Assemblies" path="/jsp/artifact/assemblies.jsp"
   */
  public class AssemblyActions extends JoinAction{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(AssemblyActions.class);
  
     /** Operation code fo showing the assembly creation form */
     public static final String FORM_OP = "form";
     /** Operation code for creating a new Assembly */
     public static final String CREATE_OP = "create";
     /** Operation code for searching assemblies using release */
     public static final String SEARCH_OP = "search";
     /** Operation code for getting details on a specific Assembly */
     public static final String DETAILS_OP = "details";
     /** Operation code for forcing status of a specified Assembly */
     public static final String STATUS_OP = "forceStatus";
  
     /**
      * The session scope attribute under which the Assembly object currently
      * selected by our logged-in User is stored.
      */
     public static final String ASSEMBLY_KEY = "assembly";
     /**
      * The request scope attribute under which the retrivied assemblies
      * list is stored.
      */
     public static final String ASSEMBLIES_KEY = "assemblies";
     /**
      * The request scope attribute under which the available deliverables
      * mapping is stored.
      */
     public static final String DELIVERABLES_KEY = "deliverablesMap";
  
     /**
      * The request scope attribute under which is stored the Assembly that
      * has raised a DuplicateEntityException during save of another one.
      */
     public static final String DUPLICATE_ASSEMBLY_KEY = "duplicate";
  
  
     // Attributes ---------------------------------------------------------------
  
    /** The artifact manager implementation to use. */
    protected ArtifactManager artifactManager = null;
    /** The assembly manager implementation to use. */
    protected AssemblyManager assemblyManager = null;
    /** The integration process manager implementation to use. */
    protected IntegrationProcessManager processManager = null;
 
 
    // Constructors -------------------------------------------------------------
 
    /** Creates a new instance of AssemblyActions. */
    public AssemblyActions(){
    }
 
 
    // Public -------------------------------------------------------------------
 
    /** @param manager The ArtifactManager implementation to use */
    public void setArtifactManager(ArtifactManager manager){
       this.artifactManager = manager;
    }
    /** @param manager The AssemblyManager implementation to use */
    public void setAssemblyManager(AssemblyManager manager){
       this.assemblyManager = manager;
    }
    /** @param manager The integration process manager implementation to use */
    public void setIntegrationProcessManager(IntegrationProcessManager manager){
       this.processManager = manager;
    }
 
 
    // Implementation of JoinAction ---------------------------------------------
 
    /**
     *
     * @param operation String representing the operation to invoke on Action
     * @param mapping Mapping between forwards name and path for this action
     * @param form The form object containing request parameters
     * @param request The servlet container request wrapper
     * @param response The servlet container response wrapper
     * @return A forward to the next view to render and display
     * @throws Exception such as InfraStructureExceptions ...
     */
    public ActionForward doExecute(String operation, ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       // Trace operation to execute.
       log.debug("doExecute() called for '" + operation + "' operation");
 
       if (FORM_OP.equals(operation)){
          return showAssemblyForm(mapping, form, request, response);
       }
       else if (CREATE_OP.equals(operation)){
          return createAssembly(mapping, form, request, response);
       }
       else if (SEARCH_OP.equals(operation)){
          return searchAssemblies(mapping, form, request, response);
       }
       else if (DETAILS_OP.equals(operation)){
          return getAssemblyDetails(mapping, form, request, response);
       }
       else if (STATUS_OP.equals(operation)){
          return forceStatus(mapping, form, request, response);
       }
       else{
          // Default : assemblies browsing page.
          request.getSession().removeAttribute(ASSEMBLY_KEY);
          return mapping.findForward("Assemblies");
       }
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Prepare all we need for displaying an assembly creation form
     * @return A forward to the next view to render and display
     */
    protected ActionForward showAssemblyForm(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
          throws Exception{
 
       if (form instanceof AssemblyForm){
          AssemblyForm aForm = (AssemblyForm)form;
 
          if (aForm.getReleaseName() != null){
             // Retrieve the release of assembly and the available assemblies & deliverables ...
             HashMap deliverablesMap = new HashMap();
             Release release = processManager.getRelease(aForm.getReleaseName());
             List assemblies = assemblyManager.getAssemblies(release);
             List types = artifactManager.getDeliverableTypes();
             // Organize available deliverables into a map.
             for (int i=0; i<types.size(); i++){
                DeliverableType type = (DeliverableType)types.get(i);
                if (type.getVersionable())
                   deliverablesMap.put(type, artifactManager.getDeliverables(type, release));
             }
 
             // If an assembly is specified for using as template, retrive it.
             if (aForm.getKey() != null){
                Assembly template = assemblyManager.getAssembly(aForm.getKey());
                // Fill form with template.
                PropertyUtils.copyProperties(aForm, template);
                Iterator deliverables = template.getDeliverables().values().iterator();
                while (deliverables.hasNext())
                   aForm.addDeliverable((Deliverable)deliverables.next());
             }
             // Put them into request attributes and form property.
             aForm.setReleaseName(release.getName());
             request.setAttribute(ASSEMBLIES_KEY, assemblies);
             request.setAttribute(DELIVERABLES_KEY, deliverablesMap);
             request.setAttribute(ReleaseActions.RELEASE_KEY, release);
          }
 
          return mapping.findForward("Form");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Create and register a new Assembly within Join application. No assembly for this
     * release and having this version info should aready exists.
     * @return A forward to the next view to render and display
     */
    protected ActionForward createAssembly(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
          throws Exception{
 
       if (form instanceof AssemblyForm){
          AssemblyForm aForm = (AssemblyForm)form;
 
          // Retrieve release and deliverables for assembly to create.
          List deliverables = new ArrayList();
          Iterator keys = aForm.getDeliverables().values().iterator();
          while (keys.hasNext()){
             String key = (String)keys.next();
             if (key != null && key.length() > 0)
                deliverables.add(artifactManager.getDeliverable(key));
          }
          Release release = processManager.getRelease(aForm.getReleaseName());
          String composerId = getUserContainer(request).getView().getUser().getLogin();
 
          // Create a new assembly and register its deliverables into manager.
          Assembly assembly = new Assembly(aForm.getVersionInfo(), aForm.getComments(), composerId, release);
          log.info("Creation of a new Assembly with key: " + assembly.getKey());
 
          try {assemblyManager.saveAssembly(assembly, deliverables);}
          catch (DuplicateEntityException dee){
             // Store exception within request.
             request.setAttribute(DUPLICATE_ASSEMBLY_KEY, dee.getOriginalEntity());
             return mapping.findForward("Form");
          }
 
          // Forward to list of assemblies for release.
          return searchAssemblies(mapping, form, request, response);
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Serch all the assemblies using the bound release criteria.
     * @return A forward to the next view to render and display
     */
    protected ActionForward searchAssemblies(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
          throws Exception{
 
       if (form instanceof AssemblyForm){
          // Get the assembly form.
          AssemblyForm aForm = (AssemblyForm)form;
 
          // Retrieve the release of assemblies to search for.
          Release release = processManager.getRelease(aForm.getReleaseName());
 
          // Retrieve the list and put it into request attribute.
          List assemblies = assemblyManager.getAssemblies(release);
          request.setAttribute(ASSEMBLIES_KEY, assemblies);
          request.setAttribute(ReleaseActions.RELEASE_KEY, release);
 
          return mapping.findForward("Assemblies");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Get all the details onto an existing Assembly.
     * @return A forward to the next view to render and display
     */
    protected ActionForward getAssemblyDetails(ActionMapping mapping, ActionForm form,
                                               HttpServletRequest request, HttpServletResponse response)
          throws Exception{
 
       if (form instanceof AssemblyForm){
          // Get the requested assembly from manager.
          AssemblyForm aForm = (AssemblyForm)form;
          Assembly assembly = assemblyManager.getAssembly(aForm.getKey());
 
          // Store assembly within request.
          request.setAttribute(ASSEMBLY_KEY, assembly);
          // Copy assembly into the form properties.
          PropertyUtils.copyProperties(aForm, assembly);
 
          return mapping.findForward("Assembly");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Force the status of a given assembly. This is a 2 step operation : retrieve possible
     * status first and display a form ; then set the choosen status for deployment.
     * @return A forward to the next view to render and display
     */
    protected ActionForward forceStatus(ActionMapping mapping, ActionForm form,
                                             HttpServletRequest request, HttpServletResponse response)
            throws Exception{
 
       if (form instanceof AssemblyForm){
          // Get the assembly form.
          AssemblyForm aForm = (AssemblyForm)form;
 
          // If no status, forward to page.
          if (aForm.getStatusKey() == null){
             request.setAttribute("statusType", "assembly");
             request.setAttribute(ASSEMBLY_KEY, assemblyManager.getAssembly(aForm.getKey()));
 
             // Build a list of possible status.
             ArrayList statusList = new ArrayList();
             statusList.addAll(processManager.getStatusForType(Status.ASSEMBLY_TYPE));
             request.setAttribute(StatusActions.STATUS_LIST_KEY, statusList);
             return mapping.findForward("Status");
          }
 
          // Find and set status to deployment.
          Status status = processManager.getStatus(aForm.getStatusKey());
          Assembly assembly = assemblyManager.getAssembly(aForm.getKey());
          assembly.setStatus(status);
          assemblyManager.saveAssembly(assembly, null);
 
          // Forward to details.
          return getAssemblyDetails(mapping, form, request, response);
       }
       // This should not happen...
       return null;
    }
 }