/**
    * 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.QuartzCronForm;
  import org.figure8.join.core.Configurable;
  import org.figure8.join.core.ContainerContextHandler;
  import org.figure8.join.core.DuplicateEntityException;
  import org.figure8.join.core.setup.BootstrapUtil;
  import org.figure8.join.core.setup.BootstrapManager;
  import org.figure8.join.services.scheduling.QuartzCronInfo;
  import org.figure8.join.services.scheduling.QuartzCronManager;
  import org.figure8.join.services.scheduling.QuartzCronParameterInfo;
  import org.figure8.join.services.security.InvalidLoginException;
  import org.figure8.join.services.remoting.CronService;
  import org.figure8.join.services.remoting.services.BeansHelper;
  import org.figure8.join.services.remoting.beans.RemoteQuartzCronInfo;
  import org.figure8.join.businessobjects.security.User;
  import org.figure8.join.util.ScriptLogAccessorProxy;
  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 com.caucho.hessian.client.HessianProxyFactory;
  
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.ByteArrayInputStream;
  import java.util.List;
  import java.util.Iterator;
  import java.util.Properties;
  import java.util.Enumeration;
  import java.rmi.RemoteException;
  /**
   * Struts action used for managing crons within Join application. 
   * @author <a href="mailto:jerome.evrard@gmail.com">Jerome Evrard</a>
   * @author <a href="mailto:laurent.broudoux@free.fr">Laurent Broudoux</a>
   * @version $Revision: 1.6 $
   * 
   * @struts.action path="/quartzCron" name="quartzCronForm"
   *                scope="request" parameter="op" validate="true"
   *                input="/pages/mainpage.jsp?body=/jsp/quartzcrons.jsp"
   * @struts.action-forward name="Crons" path="/jsp/quartzcrons.jsp"
   * @struts.action-forward name="Details" path="/jsp/quartzcrondetails.jsp"
   * @struts.action-forward name="CronHelp" path="/jsp/cronexpressionhelp.jsp"
   * @struts.action-forward name="Parameters" path="/jsp/configurableparameters.jsp"
   */
  public class QuartzCronActions extends JoinAction{
  
     // Static -------------------------------------------------------------------
  
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(QuartzCronActions.class);
  
     /** <code>SAVE_OP</code>: Action name to load a cron */
     public static final String LOAD_OP = "load";
     /** <code>SAVE_OP</code>: Action name to save a new cron */
     public static final String SAVE_OP = "save";
     /** Operation code for saving the configurable parameters of Quartz job */
     public static final String SAVE_PARAM_OP = "saveParameters";
     /** Operation code for retrieving the details and script log infos of a Quartz cron */
     public static final String DETAILS_OP = "details";
     /** Operation code for getting help about cron expression syntax */
     public static final String CRON_HELP_OP = "cronHelp";
  
     /**
      * The session scope attribute under which the cron object
      * currently selected by our logged-in User is stored.
      */
     public static final String QUARTZ_CRON_KEY = "quartzCron";
     /**
      * The session scope attribute under which the retrieved crons
      * list is stored.
      */
     public static final String QUARTZ_CRONS_KEY = "quartzCrons";
     /**
      * The request scope attribute under which is stored the cron that
      * has raised a DuplicateEntityException during save of another one.
     */
    public static final String DUPLICATE_QUARTZ_CRON_KEY = "duplicate";
 
    
    // Attributes ---------------------------------------------------------------
    
    /** <code>quartzcronManager</code>: The cron manager */
    private QuartzCronManager cronManager;
    /** <code>service</code>: Service to get a remote acces */
    private CronService service;
 
 
    // Constructors -------------------------------------------------------------
 
    /** Creates a new instance of QuartzCronActions. */
    public QuartzCronActions(){
    }
 
 
    // Public -------------------------------------------------------------------
 
    /** @param quartzCronManager The cronManager to set.*/
    public void setQuartzCronManager(QuartzCronManager quartzCronManager){
       this.cronManager = quartzCronManager;
    }
 
 
    // 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");
 
       // References cannot be injected so retrieve them.
       initializeManagerOrService();
 
       if (form instanceof QuartzCronForm){
          // We always need the list of managed quartz cron, so put it
          // directly into the appropriate request attribute.
          updateQuartzCronsInRequest(request);
 
          if (LOAD_OP.equals(operation)){
             return loadQuartzCron(mapping, (QuartzCronForm)form, request, response);
          }
          else if (SAVE_OP.equals(operation)){
             return saveQuartzCron(mapping, (QuartzCronForm)form, request, response);
          }
          else if (SAVE_PARAM_OP.equals(operation)){
             return saveQuartzCronParameters(mapping, (QuartzCronForm)form, request, response);
          }
          else if (DETAILS_OP.equals(operation)){
             return getQuartzCronDetails(mapping, (QuartzCronForm)form, request, response);
          }
          else if (CRON_HELP_OP.equalsIgnoreCase(operation)){
             return mapping.findForward("CronHelp");
          }
          else{
             // Default : empty crons management page.
             request.getSession().removeAttribute(QUARTZ_CRON_KEY);
             removeObsoleteForm(mapping, request);
             return mapping.findForward("Crons");
          }
       }
       // This should not happen...
       return null;
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * Load a specified cron info from datastore and fill form with it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward loadQuartzCron(ActionMapping mapping, QuartzCronForm form,
                                           HttpServletRequest request, HttpServletResponse response) throws Exception{
       HttpSession session = request.getSession();
       // Retrieve QuartzCronInfo corresponding to name.
       if (cronManager != null){
          // Use local manager.
          QuartzCronInfo cron = cronManager.getQuartzCron(form.getName());
          session.setAttribute(QUARTZ_CRON_KEY, cron);
          // Copy consumer into the form properties.
          PropertyUtils.copyProperties(form, cron);
          // Copy the user parameters
          Iterator itUser = cron.getJobParameterInfos().iterator();
          String strParams = "";
          while (itUser.hasNext()){
             QuartzCronParameterInfo param = (QuartzCronParameterInfo)itUser.next();
             if (!param.isJobParameter())
                strParams = strParams + param.getName() + "=" + param.getValue() +"\n";
          }
          form.setUserProperties(strParams);
       }
       else if (service != null){
          // Use remote service, require login, logout.
          String token = loginToRemoteService(request);
          RemoteQuartzCronInfo remoteCron = service.getQuartzCronInfo(token, form.getName());
          logoutFromRemoteService(token);
          // Create a local QuartzCron for storing in session.
          QuartzCronInfo cron = BeansHelper.getLocalObject(remoteCron);
          session.setAttribute(QUARTZ_CRON_KEY, cron);
          // Copy consumer into the form properties.
          PropertyUtils.copyProperties(form, remoteCron);
       }
       // Forward.
       return mapping.findForward("Crons");
    }
 
    /**
     * Load a specified cron info from datastore and fill form with it.
     * @return A forward to the next view to render and display
     */
    protected ActionForward saveQuartzCron(ActionMapping mapping, QuartzCronForm form,
                                           HttpServletRequest request, HttpServletResponse response) throws Exception{
       // Is there a cron to update in session ?
       HttpSession session = request.getSession();
       QuartzCronInfo cron = (QuartzCronInfo)session.getAttribute(QUARTZ_CRON_KEY);
 
       // Create a new cron info or populate existing one with form.
       if (cron == null){
          log.info("Creation of a new QuartzCronInfo with name: " + form.getName());
          cron = new QuartzCronInfo(form.getName(), form.getCronExpression(), "", form.getJobClass());
       }
       else{
          log.info("Update of existing QuartzCronInfo having name: " + form.getName());
          PropertyUtils.copyProperties(cron, form);
       }
 
       // Remove all the existing user parameters infos ...
       Iterator cronParams = cron.getJobParameterInfos().iterator();
       while (cronParams != null && cronParams.hasNext()){
          QuartzCronParameterInfo paramInfo = (QuartzCronParameterInfo)cronParams.next();
          if (!paramInfo.isJobParameter())
             cronParams.remove();
       }
       // Before adding the new ones.
       createUserQuartzCronParameterInfos(cron, form);
 
       // Save the cron info using manager.
       try{
          if (cronManager != null){
             log.debug("Saving QuartzCronInfo '" + form.getName() + "' using local manager");
             // Use local manager.
             cronManager.saveQuartzCronInfo(cron);
          }
          else if (service != null){
             log.debug("Saving QuartzCronInfo '" + form.getName() + "' using remote service");
             // Use remote service, require login, logout.
             String token = loginToRemoteService(request);
             service.saveCron(token, BeansHelper.getRemoteObject(cron));
             logoutFromRemoteService(token);
          }
       }
       catch (DuplicateEntityException dee){
          // Store exception within request.
          request.setAttribute(DUPLICATE_QUARTZ_CRON_KEY, dee.getOriginalEntity());
          return mapping.findForward("Crons");
       }
 
       // Forward depending of configurable nature of job class.
       if (Configurable.class.isAssignableFrom(cron.checkJobClass())){
          session.setAttribute(QUARTZ_CRON_KEY, cron);
          // Give the configurable form what it need.
          request.setAttribute(OP_PARAMETER, SAVE_PARAM_OP);
          request.setAttribute("configurableId", cron.getName());
          session.setAttribute("configurable", cron.checkJobClass().newInstance());
          request.setAttribute("action", "quartzCron");
 
          // Retrieve consumer's parameters and fill form.
          List parameters = cron.getJobParameterInfos();
          for (int i=0; i < parameters.size(); i++){
             QuartzCronParameterInfo param = (QuartzCronParameterInfo)parameters.get(i);
             if (param.isJobParameter())
                form.addParameter(param);
          }
 
          return mapping.findForward("Parameters");
       }
 
       // Remove form and session attribute if present.
       session.removeAttribute(QUARTZ_CRON_KEY);
       removeObsoleteForm(mapping, request);
       return mapping.findForward("Crons");
    }
 
    /**
     * Save a cron parameters into datastore. The cron is an already existing one.
     * @return A forward to the next view to render and display
     */
    protected ActionForward saveQuartzCronParameters(ActionMapping mapping, QuartzCronForm form,
                                                     HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       // Is there a cron to update in session ?
       HttpSession session = request.getSession();
       QuartzCronInfo cron = (QuartzCronInfo)session.getAttribute(QUARTZ_CRON_KEY);
 
       if (cron != null){
          log.info("Adding QuartzCronParameterInfo to quartz cron: " + cron.getName());
          // Remove all the existing job parameters infos.
          Iterator cronParams = cron.getJobParameterInfos().iterator();
          while (cronParams != null && cronParams.hasNext()){
             QuartzCronParameterInfo paramInfo = (QuartzCronParameterInfo)cronParams.next();
             if (paramInfo.isJobParameter())
                cronParams.remove();
          }
 
          // Browse parameters present in form.
          Iterator parameters = form.getParameters().keySet().iterator();
          while (parameters != null && parameters.hasNext()){
             // Retrieve name, value pairs.
             String name = (String)parameters.next();
             String value = (String)form.getMappedParameter(name);
             if (log.isDebugEnabled())
                log.debug("Adding a cron parameter: " + name + "=" + value);
             // Add a new parameter info to consume.
             QuartzCronParameterInfo paramInfo = new QuartzCronParameterInfo(name, value, true);
             cron.addJobParameterInfo(paramInfo);
          }
 
          if (cronManager != null){
             log.debug("Saving quartz cron '" + form.getName() + "' parameters using local manager");
             // Use local manager.
             cronManager.saveQuartzCronInfo(cron);
          }
          else if (service != null){
             log.debug("Saving quartz cron '" + form.getName() + "' parameters using remote service");
             // Use remote service.
             String token = loginToRemoteService(request);
             service.saveCron(token, BeansHelper.getRemoteObject(cron));
             logoutFromRemoteService(token);
          }
       }
       // Remove form and session attribute if present.
       session.removeAttribute(QUARTZ_CRON_KEY);
       removeObsoleteForm(mapping, request);
       return mapping.findForward("Crons");
    }
 
    /**
     * Get all the details of a registered quartz cron from datastore. This includes getting its execution logs infos.
     * @return A forward to the next view to render and display
     */
    protected ActionForward getQuartzCronDetails(ActionMapping mapping, QuartzCronForm form,
                                                 HttpServletRequest request, HttpServletResponse response)
            throws Exception{
       if (cronManager != null){
          // Use local manager.
          QuartzCronInfo info = cronManager.getQuartzCron(form.getName());
          request.setAttribute(QUARTZ_CRON_KEY, info);
       }
       else if (service != null){
          // Use remote service.
          String token = loginToRemoteService(request);
          RemoteQuartzCronInfo info = service.getQuartzCronInfo(token, form.getName());
          logoutFromRemoteService(token);
          request.setAttribute(QUARTZ_CRON_KEY, info);
       }
       // Get information on execution logs.
       ScriptLogAccessorProxy proxy = ScriptLogAccessorProxy.getInstance();
       List logInfos = proxy.getScriptLogInfos(form.getName(), "QuartzAdapter");
       request.setAttribute("scriptLogInfos", logInfos);
       
       // Forward to details.
       return mapping.findForward("Details");
    }
 
    /**
     * Update the crons definitions collection within request.
     * @param request The servlet container request wrapper
     * @throws Exception if consumers cannot be refreshed
     */
    protected void updateQuartzCronsInRequest(HttpServletRequest request) throws Exception{
       if (cronManager != null){
          // Use local manager.
          request.setAttribute(QUARTZ_CRONS_KEY, cronManager.getQuartzCronInfos());
       }
       else if (service != null){
          // Use remote service (require login, logout).
          String token = loginToRemoteService(request);
          request.setAttribute(QUARTZ_CRONS_KEY, service.getQuartzCronInfo(token));
          logoutFromRemoteService(token);
       }
    }
 
    /**
     * Initialize the local consumer manager or the remote service depending
     * on the application setup and the application side we are on.
     * @throws Exception if manager cannot be found or remote service is not available
     */
    protected void initializeManagerOrService() throws Exception{
       if (cronManager == null && service == null){
          BootstrapManager bootstrapManager = BootstrapUtil.getBootstrapManager();
          // Use remote service only if we are on synchronous side of a dissociate setup.
          if (bootstrapManager.isDissociatedSetup() && bootstrapManager.isSynchronousSide()){
             String url = bootstrapManager.getOtherSideUrl() + "/remoting/hessian/CronService";
             log.info("Connecting to remote CronService using url: " + url);
             HessianProxyFactory proxyFactory = new HessianProxyFactory();
             service = (CronService)proxyFactory.create(CronService.class, url);
          }
          else{
             // Use local manager provided by container facility.
             log.info("Looking up local QuartzCronManager using 'quartzCronManager' component");
             ContainerContextHandler handler = ContainerContextHandler.getInstance();
             cronManager = (QuartzCronManager)handler.getComponent("quartzCronManager");
          }
       }
    }
 
 
    // Private ------------------------------------------------------------------
 
    /**
     * Create the user parameters of the current edited cron from formular.
     * @param cron The cron to create parameters for
     * @param form The current edited formular.
     */
    private void createUserQuartzCronParameterInfos(QuartzCronInfo cron, QuartzCronForm form){
       // Parse the string rpresenting user properties.
       Properties properties = new Properties();
       try{
          InputStream is = new ByteArrayInputStream(form.getUserProperties().getBytes());
          properties.load(is);
       }
       catch (IOException ioe){
          ioe.printStackTrace();
       }
       Enumeration enumUserProps = properties.keys();
       while (enumUserProps.hasMoreElements()){
          // Create the new Quartz cron parameter
          String name = (String)enumUserProps.nextElement();
          String value = properties.getProperty(name);
          QuartzCronParameterInfo parameter = new QuartzCronParameterInfo(name, value, false);
          cron.addJobParameterInfo(parameter);
       }
    }
 
    /** Login for using the remote service. */
    private String loginToRemoteService(HttpServletRequest request) throws InvalidLoginException, RemoteException{
       // Extract user and its clear password from request.
       User user = getUserContainer(request).getView().getUser();
       String pwd = getUserContainer(request).getView().getClearPassword();
       // Logon to remote service, get a token.
       String token = service.login(user.getLogin(), pwd);
       return token;
    }
 
    /** Logout from the remote service. */
    private void logoutFromRemoteService(String token) throws RemoteException{
       service.logout(token);
    }
 }