/**
    * 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.control.action;
  
  import org.figure8.join.control.JoinAction;
  import org.figure8.join.control.form.EnvironmentMappingForm;
  import org.figure8.join.businessobjects.environment.EnvironmentMapping;
  import org.figure8.join.businessobjects.environment.LogicalEnvironment;
  import org.figure8.join.businessobjects.environment.PhysicalEnvironment;
  import org.figure8.join.businessfacades.environment.EnvironmentManager;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  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.ArrayList;
  /**
   * This is a Struts action for managing all operations related mappings between Logical and Physical environments.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.2 $
   *
   * @struts.action path="/environmentMapping" name="envMappingForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/environment/environmentmappings.jsp"
   * @struts.action-forward name="Environments" path="/action/logicalEnvironment?op=view"
   * @struts.action-forward name="EnvironmentMapping" path="/jsp/environment/environmentmapping.jsp"
   * @struts.action-forward name="EnvironmentMappings" path="/jsp/environment/environmentmappings.jsp"
   */
  public class EnvironmentMappingActions extends JoinAction{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger */
     private static final Log log = LogUtil.getLog(EnvironmentMappingActions.class);
  
     /** Operation code for showing an environment mapping form */
     public static final String FORM_OP = "form";
     /** Operation code for loading a specific EnvironmentMapping */
     public static final String LOAD_OP = "load";
     /** Operation code for saving a EnvironmentMapping (create) */
     public static final String CREATE_OP = "create";
     /** Operation code for closing a EnvironmentMapping (close) */
     public static final String CLOSE_OP = "close";
     /** Operation code for retrieving EnvironmentMappings for an environment (logical or physical) */
     public static final String VIEW_OP = "view";
  
     /**
      * The session scope attribute under which the EnvironmentMapping object
      * currently selected by our logged-in User is stored.
      */
     public static final String MAPPING_KEY = "mapping";
     /**
      * The request scope attribute under which the retrieved EnvironmentMappings
      * list is stored.
      */
     public static final String MAPPINGS_KEY = "mappings";
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The EnvironmentManager to use. */
     private EnvironmentManager environmentManager = null;
  
  
     // Constructors -------------------------------------------------------------
  
     /** Creates a new instance of EnvironmentMappingActions */
     public EnvironmentMappingActions(){
     }
  
  
     // Public -------------------------------------------------------------------
  
     /** @param envManager The EnvironmentManager implementation instance to use */
     public void setEnvironmentManager(EnvironmentManager envManager){
        this.environmentManager = envManager;
     }
  
  
     // 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 showMappingForm(mapping, form, request, response);
       }
       else if (LOAD_OP.equals(operation)){
          return loadMapping(mapping, form, request, response);
       }
       else if (CREATE_OP.equals(operation)){
          return createMapping(mapping, form, request, response);
       }
       else if (CLOSE_OP.equals(operation)){
          return closeMapping(mapping, form, request, response);
       }
       else if (VIEW_OP.equals(operation)){
          return loadEnvironmentMappings(mapping, form, request, response);
       }
       // This should not happen...
       return null;
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Prepare all we need for displaying a mapping creation form
     * @return A forward to the next view to render and display
     */
    protected ActionForward showMappingForm(ActionMapping mapping, ActionForm form,
                                            HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof EnvironmentMappingForm){
          // Prepare form for requested logical environment.
          EnvironmentMappingForm mForm = (EnvironmentMappingForm)form;
          LogicalEnvironment logicalEnvironment = environmentManager.getLogicalEnvironment(mForm.getLogicalEnvKey());
 
          // Retrieve physical environments that are candidates for a new mapping.
          List candidates = new ArrayList();
          List environments = environmentManager.getPhysicalEnvironments();
          for (int i=0; i<environments.size(); i++){
             PhysicalEnvironment environment = (PhysicalEnvironment)environments.get(i);
             if (environment.getActiveEnvironmentMapping() == null)
                candidates.add(environment);
          }
          // Store environment & candidates into request attributes.
          request.setAttribute(LogicalEnvironmentActions.ENVIRONMENT_KEY, logicalEnvironment);
          request.setAttribute(PhysicalEnvironmentActions.ENVIRONMENTS_KEY, candidates);
 
          // Add current mapping info if possible.
          if (logicalEnvironment.getActiveEnvironmentMapping() != null){
             EnvironmentMapping envMapping = logicalEnvironment.getActiveEnvironmentMapping();
             request.setAttribute(MAPPING_KEY, envMapping);
          }
          return mapping.findForward("EnvironmentMapping");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Load a specified environment mapping from datastore and fill form with it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward loadMapping(ActionMapping mapping, ActionForm form,
                                        HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof EnvironmentMappingForm){
          // Get the requested environment mapping from manager.
          EnvironmentMappingForm mForm = (EnvironmentMappingForm)form;
          EnvironmentMapping envMapping = environmentManager.getEnvironmentMapping(mForm.getId());
 
          // Store mapping into request before forwarding.
          request.setAttribute(MAPPING_KEY, envMapping);
          return mapping.findForward("EnvironmentMapping");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Create an environment mapping into datastore and bind specified logical
     * and physical environments to it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward createMapping(ActionMapping mapping, ActionForm form,
                                          HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof EnvironmentMappingForm){
          // Get the requested environments from manager.
          EnvironmentMappingForm mForm = (EnvironmentMappingForm)form;
          LogicalEnvironment logicalEnv = environmentManager.getLogicalEnvironment(mForm.getLogicalEnvKey());
          PhysicalEnvironment physicalEnv = environmentManager.getPhysicalEnvironment(mForm.getPhysicalEnvKey());
 
          // Map environments by creating a mapping.
          log.info("Creating a mapping for " + logicalEnv.getKey() + " logical environment onto "
                  + physicalEnv.getKey() + " physical one");
          environmentManager.mapEnvironments(logicalEnv, physicalEnv);
 
          // Store logicalEnv into request, asking to refresh its view, before forwarding...
          request.setAttribute(LogicalEnvironmentActions.ENVIRONMENT_KEY, logicalEnv);
          return mapping.findForward("Environments");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Close an environment mapping and update the related logical and physical environments.
     * @return A forward to the next view to render and display
     */
    protected ActionForward closeMapping(ActionMapping mapping, ActionForm form,
                                         HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof EnvironmentMappingForm){
          // Get the requested environment mapping from manager.
          EnvironmentMappingForm mForm = (EnvironmentMappingForm)form;
          EnvironmentMapping envMapping = environmentManager.getEnvironmentMapping(mForm.getId());
 
          // Close environment mapping using manager.
          log.info("Closing the environment mapping having identifier '" + envMapping.getId() + "'");
          environmentManager.closeEnvironmentMapping(envMapping);
 
          // Store logicalEnv into request, asking to refresh its view, before forwarding...
          request.setAttribute(LogicalEnvironmentActions.ENVIRONMENT_KEY, envMapping.getLogicalEnvironment());
          return mapping.findForward("Environments");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Retrieve and load into request all the environment mappings history corresponding to
     * a logical or a physical environment.
     * @return A forward to the next view to render and display
     */
    protected ActionForward loadEnvironmentMappings(ActionMapping mapping, ActionForm form,
                                                    HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof EnvironmentMappingForm){
          // Retrieve mapping form and prepare null list.
          EnvironmentMappingForm mForm = (EnvironmentMappingForm)form;
          List mappings = null;
 
          if (mForm.getLogicalEnvKey() != null){
             // Log and get appropriate list.
             log.info("Retrieving the EnvironmentMapping history for logical environment: " + mForm.getLogicalEnvKey());
             LogicalEnvironment logicalEnv = environmentManager.getLogicalEnvironment(mForm.getLogicalEnvKey());
             mappings = environmentManager.getEnvironmentMappings(logicalEnv);
             // Put the corresponding title and cirterion.
             request.setAttribute("criterion", "logicalenv");
             request.setAttribute("environment", logicalEnv);
             request.setAttribute("title.key", "title.envmappings.bylogicalenv");
          }
          else if (mForm.getPhysicalEnvKey() != null){
             // Log and get appropriate list.
             log.info("Retrieving the EnvironmentMapping history for physical environment: "
                         + mForm.getPhysicalEnvKey());
             PhysicalEnvironment physicalEnv = environmentManager.getPhysicalEnvironment(mForm.getPhysicalEnvKey());
             mappings = environmentManager.getEnvironmentMappings(physicalEnv);
             // Put the corresponding title and cirterion.
             request.setAttribute("criterion", "physicalenv");
             request.setAttribute("environment", physicalEnv);
             request.setAttribute("title.key", "title.envmappings.byphysicalenv");
          }
 
          // Store mappings list into request before forwarding.
          request.setAttribute(MAPPINGS_KEY, mappings);
          return mapping.findForward("EnvironmentMappings");
       }
       // This should not happen...
       return null;
    }
 }