/**
    * 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.PhysicalEnvironmentForm;
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.businessobjects.environment.PhysicalEnvironment;
  import org.figure8.join.businessobjects.environment.LogicalEnvironment;
  import org.figure8.join.businessobjects.environment.EnvironmentMapping;
  import org.figure8.join.businessfacades.environment.EnvironmentManager;
  import org.figure8.join.view.PhysicalEnvironmentTrackingView;
  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.HttpSession;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import java.util.Calendar;
  /**
   * Struts action used for managing physical environments within Join application.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.3 $
   *
   * @struts:action path="/physicalEnvironment" name="physicalEnvForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/environment/physicalenvironment.jsp"
   * @struts.action-forward name="Environments" path="/jsp/environment/physicalenvironment.jsp"
   * @struts.action-forward name="EnvironmentViews" path="/jsp/environment/environmentview.jsp"
   * @struts.action-forward name="EnvironmentTrackingView" path="/jsp/environment/environmenttrackingview.jsp"
   */
  public class PhysicalEnvironmentActions extends JoinAction{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(PhysicalEnvironmentActions.class);
  
     /** Operation code for loading a specific PhysicalEnvironment */
     public static final String LOAD_OP = "load";
     /** Operation code for saving a PhysicalEnvironment (create or update) */
     public static final String SAVE_OP = "save";
     /** Operation code for accessing PhysicalEnvironment view screen */
     public static final String VIEW_OP = "view";
     /** Operation code for getting details on a specified PhysicalEnvironment view */
     public static final String DETAILS_OP = "details";
     /** Operation code for getting environment configuration details at specified date */
     public static final String CONFIG_OP = "config";
     /** Operation code for getting environment configuration changes for tracking period */
     public static final String CHANGES_OP = "changes";
  
     /**
      * The session scope attribute under which the PhysicalEnvironment object
      * currently selected by our logged-in User is stored.
      */
     public static final String ENVIRONMENT_KEY = "environment";
     /**
      * The request scope attribute under which the LogicalENvironment object
      * selected is stored.
      */
     public static final String LOGICAL_ENVIRONMENT_KEY = "logicalEnvironment";
     /**
      * The request scope attribute under which the retrieved PhysicalEnvironments
      * list is stored.
      */
     public static final String ENVIRONMENTS_KEY = "environments";
     /**
      * The request scope attribute under which the date corresponding
      * to environment configuration view is stored.
      */
     public static final String VIEW_DATE_KEY = "viewDate";
     /**
      * The request scope attribute under which the configuration changes view
      * for a tracking period is stored.
      */
     public static final String TRACKING_VIEW_KEY = "trackingView";
     /**
      * The request scope attribute under which is stored the PhysicalEnvironment that
      * has raised a DuplicateEntityException during save of another one.
      */
     public static final String DUPLICATE_ENVIRONMENT_KEY = "duplicate";
 
 
    // Attributes ---------------------------------------------------------------
 
    /** The EnvironmentManager to use. */
    private EnvironmentManager environmentManager = null;
 
 
    // Constructors -------------------------------------------------------------
 
    /** Creates a new PhysicalEnvironmentActions. */
    public PhysicalEnvironmentActions(){
    }
 
 
    // 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 (LOAD_OP.equals(operation)){
          return loadEnvironment(mapping, form, request, response);
       }
       else if (SAVE_OP.equals(operation)){
          return saveEnvironment(mapping, form, request, response);
       }
       else if (DETAILS_OP.equals(operation)){
          return getEnvironmentDetails(mapping, form, request, response);
       }
       else if (CONFIG_OP.equals(operation)){
          return getEnvironmentConfigAtDate(mapping, form, request, response);
       }
       else if (CHANGES_OP.equals(operation)){
          return getEnvironmentChanges(mapping, form, request, response);
       }
       else{
          // Default : empty environment management page.
          request.getSession().removeAttribute(ENVIRONMENT_KEY);
          // Load the environments list.
          request.setAttribute(ENVIRONMENTS_KEY, environmentManager.getPhysicalEnvironments());
          // Forward to view if specified.
          if (VIEW_OP.equals(operation))
             return mapping.findForward("EnvironmentViews");
          // Forward to management screen.
          return mapping.findForward("Environments");
       }
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Load a specified physical environment from datastore and fill form with it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward loadEnvironment(ActionMapping mapping, ActionForm form,
                                            HttpServletRequest request, HttpServletResponse response) throws Exception{
       if (form instanceof PhysicalEnvironmentForm){
          // Get the requested environment from manager.
          PhysicalEnvironmentForm envForm = (PhysicalEnvironmentForm)form;
          PhysicalEnvironment environment = environmentManager.getPhysicalEnvironment(envForm.getId());
 
          // Store environment within session.
          HttpSession session = request.getSession();
          session.setAttribute(ENVIRONMENT_KEY, environment);
          // Copy environment into form properties.
          PropertyUtils.copyProperties(envForm, environment);
 
          // Load the environment list and forward.
          request.setAttribute(ENVIRONMENTS_KEY, environmentManager.getPhysicalEnvironments());
          return mapping.findForward("Environments");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Save a physical environment into datastore. The Target may be an already existing
     * one or a new one (this is indeed a create or update method).
     * @return A forward to the next view to render and display
     */
    protected ActionForward saveEnvironment(ActionMapping mapping, ActionForm form,
                                            HttpServletRequest request, HttpServletResponse response) throws Exception{
       if (form instanceof PhysicalEnvironmentForm){
          // Get the environment form.
          PhysicalEnvironmentForm envForm = (PhysicalEnvironmentForm)form;
 
          // Is there an environment to update in session ?
          HttpSession session = request.getSession();
          PhysicalEnvironment environment = (PhysicalEnvironment)session.getAttribute(ENVIRONMENT_KEY);
 
          // Create a new environment or populate existing with form.
          if (environment == null){
             log.info("Creation of a new PhysicalEnvironment with key:" + envForm.getKey());
             environment = new PhysicalEnvironment(envForm.getKey(), envForm.getName());
          }
          else{
             log.info("Update of existing PhysicalEnvironment having key: " + envForm.getKey());
             PropertyUtils.copyProperties(environment, envForm);
          }
          // Save environment using manager.
          try {environmentManager.savePhysicalEnvironment(environment);}
          catch (DuplicateEntityException dee){
             // Store exception within request.
             request.setAttribute(DUPLICATE_ENVIRONMENT_KEY, dee.getOriginalEntity());
             request.setAttribute(ENVIRONMENTS_KEY, environmentManager.getPhysicalEnvironments());
             return mapping.findForward("Environments");
          }
 
          // Remove form and session attribute if present.
          session.removeAttribute(ENVIRONMENT_KEY);
          removeObsoleteForm(mapping, request);
 
          // Load the environments list and forward.
          request.setAttribute(ENVIRONMENTS_KEY, environmentManager.getPhysicalEnvironments());
          return mapping.findForward("Environments");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Load a specified physical environment from datastore and fill form with it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward getEnvironmentDetails(ActionMapping mapping, ActionForm form,
                                                  HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       if (form instanceof PhysicalEnvironmentForm){
          // Get the requested environment from manager.
          PhysicalEnvironment environment = null;
          PhysicalEnvironmentForm envForm = (PhysicalEnvironmentForm)form;
 
          if (!envForm.isFromLogical()){
             log.debug("Getting environment details for PhysicalEnvironment '" + envForm.getId() + "'");
             environment = environmentManager.getPhysicalEnvironment(envForm.getId());
             request.setAttribute(ENVIRONMENTS_KEY, environmentManager.getPhysicalEnvironments());
          }
          else{
             log.debug("Getting environment details for LogicalEnvironment '" + envForm.getId() + "'");
             LogicalEnvironment logicalEnvironment = environmentManager.getLogicalEnvironment(envForm.getId());
             environment = logicalEnvironment.getActiveEnvironmentMapping().getPhysicalEnvironment();
             request.setAttribute(LOGICAL_ENVIRONMENT_KEY, logicalEnvironment);
          }
 
          // Load the environments list and forward.
          request.setAttribute(ENVIRONMENT_KEY, environment);
          return mapping.findForward("EnvironmentViews");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Load a specified physical environmnet from datastore ad get its configuration
     * a precise datetime (use startDate, startHour and startMin from form).
     * @return A forward to the new view to render and display
     */
    protected ActionForward getEnvironmentConfigAtDate(ActionMapping mapping, ActionForm form,
                                                       HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       if (form instanceof PhysicalEnvironmentForm){
          // Get the requested environment view at date from manager.
          PhysicalEnvironmentForm envForm = (PhysicalEnvironmentForm)form;
 
          // Build correct datetime from form and request locale. 
          Calendar date = Calendar.getInstance(request.getLocale());
          date.setTime(envForm.getStartDate());
          date.set(Calendar.HOUR_OF_DAY, envForm.getStartHour());
          date.set(Calendar.MINUTE, envForm.getStartMin());
 
          // Get configuration view.
          PhysicalEnvironment view = null;
          if (!envForm.isFromLogical()){
             log.debug("Getting environment coniguration for PhysicalEnvironment '" + envForm.getKey() + "'");
             view = environmentManager.getPhysicalEnvironmentAtDate(envForm.getKey(), date.getTime());
             request.setAttribute(ENVIRONMENTS_KEY, environmentManager.getPhysicalEnvironments());
          }
          else{
             log.debug("Getting environment configuration for LogicalEnvironment '" + envForm.getKey() + "'");
             // Retrieve mapping active at wanted date.
             LogicalEnvironment logicalEnvironment = environmentManager.getLogicalEnvironment(envForm.getKey());
             EnvironmentMapping envMapping = environmentManager.getEnvironmentMappingAtDate(logicalEnvironment,
                                                                                                 date.getTime());
             // If no mapping, set an empty environemnt.
             if (envMapping != null)
                view = environmentManager.getPhysicalEnvironmentAtDate(envMapping.getPhysicalEnvironment().getKey(),
                                                                         date.getTime());
             else view = new PhysicalEnvironment();
 
             request.setAttribute(LOGICAL_ENVIRONMENT_KEY, logicalEnvironment);
          }
 
          // Store configuration view, date and forward.
          request.setAttribute(ENVIRONMENT_KEY, view);
          request.setAttribute(VIEW_DATE_KEY, date.getTime());
          return mapping.findForward("EnvironmentViews");
       }
       // This should not happen...
       return null;
    }
 
 
    /**
     * Load a specified physical environment from datastore and get its configuration
     * changes during specified period (use startDate and endDate from form).
     * @return A forward to the next view to render and display
     */
    protected ActionForward getEnvironmentChanges(ActionMapping mapping, ActionForm form,
                                                  HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       if (form instanceof PhysicalEnvironmentForm){
          // Get the requested environment tracking view from manager.
          PhysicalEnvironmentForm envForm = (PhysicalEnvironmentForm)form;
          PhysicalEnvironmentTrackingView view = environmentManager.getPhysicalEnvironmentTrackingView(envForm.getKey(),
                                                                         envForm.getStartDate(), envForm.getEndDate());
 
          // Store tracking view and forward.
          request.setAttribute(TRACKING_VIEW_KEY, view);
          return mapping.findForward("EnvironmentTrackingView");
       }
       // This should not happen...
       return null;
    }
 }