/**
    * 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.ResourceForm;
  import org.figure8.join.control.form.ResourceTypeForm;
  import org.figure8.join.core.InfrastructureException;
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.businessobjects.environment.ResourceType;
  import org.figure8.join.businessobjects.environment.AbstractResourceType;
  import org.figure8.join.businessfacades.environment.ResourceManager;
  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.ActionMapping;
  import org.apache.struts.action.ActionForward;
  
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import java.lang.reflect.Constructor;
  /**
   * This is a Struts action for managing all operations related to AbstractResourceType entities.
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.1 $
   *
   * @struts.action path="/resourceType" name="resourceTypeForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/environment/resourcetypes.jsp"
   * @struts.action-forward name="ResourceTypes" path="/jsp/environment/resourcetypes.jsp"
   */
  public class ResourceTypeActions extends JoinAction{
     
     // Static -------------------------------------------------------------------
     
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(ResourceTypeActions.class);
  
     /** Operation code for loading a specified ResourceType */
     public static final String LOAD_OP = "load";
     /** Operation code for saving (create or update) a specified ResourceType */
     public static final String SAVE_OP = "save";
  
     /**
      * The session scope attribute under which the ResourceType object
      * currently selected by our logged-in User is stored.
      */
     public static final String RESOURCE_TYPE_KEY = "resourceType";
     /**
      * The request scope attribute under which the retrieved ResourceTypes
      * list is stored.
      */
     public static final String RESOURCE_TYPES_KEY = "resourceTypes";
     /**
      * The request scope attribute under which is stored the ResourceTypes that
      * has raised a DuplicateEntityException during save of another one.
      */
     public static final String DUPLICATE_RESOURCE_TYPE_KEY = "duplicate";
  
  
     // Attributes ---------------------------------------------------------------
  
     /** The ResourceManager to use */
     private ResourceManager resourceManager = null;
  
  
     // Constructors -------------------------------------------------------------
     
     /** Creates a new instance of ResourceTypeActions */
     public ResourceTypeActions(){
     }
   
     
     // Public -------------------------------------------------------------------
  
     /** @param manager The ResourceManager to use */
     public void setResourceManager(ResourceManager manager){
        this.resourceManager = manager;
     }
  
     /**
      * Create a new resource type instance from informations contained into ResourceTypeForm.
      * This is a hook to allow subclasses treating specific resource categories. This implementation
     * maskes 2 assumptions : it is looking for a class named <code>form.getCategory() + "Type"</code>
     * and this it needs to have a constructor with 2 string parameters (the resource type key
     * and its label).
     * @param form The ResourceTypeForm (or a subclass) to create persistent resource type from
     * @return The persistent AbstractResourceType corresponding to given form
     */
    public AbstractResourceType createResourceTypeInstance(ResourceTypeForm form){
       String classStr = ResourceForm.getSupportedImplementation(form.getCategory());
       try{
          Class clazz = Thread.currentThread().getContextClassLoader().loadClass(classStr + "Type");
          Constructor constructor = clazz.getDeclaredConstructor(new Class[]{String.class, String.class});
          return (AbstractResourceType)constructor.newInstance(new Object[]{form.getKey(), form.getLabel()});
       }
       catch (ClassNotFoundException cnfe){
          // Log and wrap this into infrastructure exception.
          log.error("ClassNotFoundException while trying to load " + classStr + "Type class");
          log.error("Check your supported resource categories...");
          throw new InfrastructureException("Unable to load specified resource type category", cnfe);
       }
       catch (NoSuchMethodException nsme){
          // Log and wrap this into infrastructure exception.
          log.error("NoSuchMethodException while trying to get " + classStr + "Type constructor");
          log.error("Check your supported resource categories...");
          throw new InfrastructureException("Unable to create specified resource type category", nsme);
       }
       catch (Exception e){
          // Log and wrap this into infrastructure exception.
          log.error("Unexpected exception while trying to create a " + classStr + "Type instance");
          log.error("Here'svthe detailed error message: " + e.getMessage());
          throw new InfrastructureException("Unexpected exception while trying to create a resource type", e);
       }
    }
 
 
    // 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
     */
    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 loadResourceType(mapping, form, request, response);
       }
       else if (SAVE_OP.equals(operation)){
          return saveResourceType(mapping, form, request, response);
       }
       else{
          // Default : empty resource types management page.
          request.getSession().removeAttribute(RESOURCE_TYPE_KEY);
          request.setAttribute(RESOURCE_TYPES_KEY, resourceManager.getResourceTypes(request.getParameter("category")));
          return mapping.findForward("ResourceTypes");
       }
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Load a specified resource type from datastore and fill form with it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward loadResourceType(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof ResourceTypeForm){
          // Get the request resource type from manager.
          ResourceTypeForm rForm = (ResourceTypeForm)form;
          ResourceType type = resourceManager.getResourceType(rForm.getKey());
 
          // Store resource type within session.
          HttpSession session = request.getSession();
          session.setAttribute(RESOURCE_TYPE_KEY, type);
          // Copy resource type into form properties.
          PropertyUtils.copyProperties(rForm, type);
 
          // Add resource types list before forwarding.
          request.setAttribute(RESOURCE_TYPES_KEY, resourceManager.getResourceTypes(rForm.getCategory()));
          return mapping.findForward("ResourceTypes");
       }
       // This should not happen...
       return null;
    }
 
    /**
     * Save a resource type into datastore. The resource type 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 saveResourceType(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
       throws Exception{
 
       if (form instanceof ResourceTypeForm){
          ResourceTypeForm rForm = (ResourceTypeForm)form;
 
          // Is there a resource type to update in session ?
          HttpSession session = request.getSession();
          AbstractResourceType type = (AbstractResourceType)session.getAttribute(RESOURCE_TYPE_KEY);
 
          // Create a new resource type or populate existing with form.
          if (type == null){
             log.info("Creation of a new ResourceType with key: " + rForm.getKey());
             type = createResourceTypeInstance(rForm);
          }
          else{
             log.info("Update of existing ResourceType having key: " + rForm.getKey());
             PropertyUtils.copyProperties(type, rForm);
          }
          // Save resource type using manager.
          try {resourceManager.saveResourceType(type);}
          catch (DuplicateEntityException dee){
             // Store exception within request.
             request.setAttribute(DUPLICATE_RESOURCE_TYPE_KEY, dee.getOriginalEntity());
             request.setAttribute(RESOURCE_TYPES_KEY, resourceManager.getResourceTypes(rForm.getCategory()));
             return mapping.findForward("ResourceTypes");
          }
 
          // Remove form and session attribute if present.
          session.removeAttribute(RESOURCE_TYPE_KEY);
          removeObsoleteForm(mapping, request);
 
          // Add resource types list before forwarding.
          request.setAttribute(RESOURCE_TYPES_KEY, resourceManager.getResourceTypes(rForm.getCategory()));
          return mapping.findForward("ResourceTypes");
       }
       // This should not happen...
       return null;
    }
 }