/**
    * 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.services.scripting;
  
  import org.figure8.join.core.EntityObject;
  import org.figure8.join.core.InvalidParameterException;
  import org.figure8.join.services.scheduling.QuartzCronManager;
  import org.figure8.join.services.scheduling.QuartzCronParameterInfo;
  import org.figure8.join.util.LogUtil;
  
  import org.apache.commons.logging.Log;
  import org.quartz.Job;
  import org.quartz.JobExecutionContext;
  import org.quartz.JobExecutionException;
  
  import java.io.File;
  import java.io.FileOutputStream;
  import java.io.FileNotFoundException;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.Properties;
  /**
   * This is a base class for Quartz jobs that wants to launch script when
   * the time scheduled with cron arrive. It acts as an adapter between the
   * scheduled batch world and the {@link ScriptLauncher} facilities.
   * <br/>
   * This class is a Quartz {@link Job} that is {@link org.figure8.join.core.Configurable}.
   * <br/>
   *
   * @see org.figure8.join.core.Configurable
   * 
   * @author <a href="mailto:jerome.evrard@gmail.com">Jerome Evrard</a>
   * @version $Revision: 1.2 $
   */
  public abstract class ScriptLauncherQuartzAdapter extends ScriptLauncherAdapterSupport implements Job{
  
     // Static -------------------------------------------------------------------
     
     /** Get a commons logger. */
     private static final Log log = LogUtil.getLog(ScriptLauncherQuartzAdapter.class);
  
  
     // Implementation of Job ----------------------------------------------------
     
     /**
      * This method is executed when scheduled time is reached.
      * @param context The execution context of the job (contains job's user parameters)
      */
     public void execute(JobExecutionContext context) throws JobExecutionException{
        // Name has not been set, so correct before creating log.
        setName(context.getJobDetail().getName());
        ScriptLogInfo logInfo = null;
        File logFile = createNewLogFile();
  
        // First, check if the cron entity is present in context & create the script log.
        Object entity = getParameterFromContext(QuartzCronManager.JOB_ENTITY, context);
        if (entity != null && entity instanceof EntityObject){
           log.debug("An Entity is present into execution context: " + entity);
           logInfo = new ScriptLogInfo((EntityObject)entity, logFile.getPath().replace('\\', '/'),
                   context.getJobDetail().getName(), "QuartzAdapter", "Unknown file path");
        }
        else{
           logInfo = new ScriptLogInfo(logFile.getPath().replace('\\', '/'),
                   context.getJobDetail().getName(), "QuartzAdapter", "Unknown file path");
        }
        // Configure the job using parameters from context.
        try {configureJobFromContext(context);}
        catch (InvalidParameterException ipe){
           log.fatal("Exception while configuring the Job using parameters present into JobExecutionContext");
           log.fatal("Here's the detailed message: " + ipe.getMessage());
           // Save the log info if it exists and if context is available.
           if (logInfo != null){
              logInfo.setExceptionMsg(ipe.getMessage());
              saveLogInfoIfAvailable(logInfo);
           }
           return;
        }
        // Complete the script log info instance with script path.
        if (logInfo != null){
           logInfo.setScriptFile(getScriptLauncher().getScriptPath());
        }
  
        // Transform the JobDataMap into properties
        Properties jobProperties = new Properties(); 
        Iterator dataKeys = context.getJobDetail().getJobDataMap().keySet().iterator();
        while (dataKeys.hasNext()){
           // Get the next data map key and value.
          Object key = dataKeys.next();
          Object value = getParameterFromContext(key.toString(), context);
          if (value != null && value instanceof QuartzCronParameterInfo){
             QuartzCronParameterInfo param = (QuartzCronParameterInfo)value;
             if (!param.isJobParameter())
                jobProperties.put(key.toString(), param.getValue());
          }
          else jobProperties.put(key.toString(), value);
       }
 
       try{
          // Launching script (log start time).
          if (log.isInfoEnabled())
             log.info("Launching the script of '" + name + "' Quartz adapter. Start time is: " + new Date());
          // Set the log outputstream and run the job script !
          getScriptLauncher().setLogOutputStream(new FileOutputStream(logFile));
          getScriptLauncher().runScript(jobProperties);
          // Log the execution result.
          context.setResult(new Integer(0));
          logInfo.setExceptionMsg("Execution is properly terminated.");
       }
       catch (ScriptException se){
          // Store and log the exception
          context.setResult(new Integer(1));
          log.error("ScriptException when running " + getScriptLauncher().getScriptPath() + ": " + se.getMessage());
          // Put exception message into log info instance.
          if (logInfo != null)
             logInfo.setExceptionMsg(se.getMessage());
       }
       catch (FileNotFoundException fnfe){
          // Store and log the exception.
          log.error("FileNotFoundException while getting OS on " + logFile.getPath() + ": " + fnfe.getMessage());
          context.setResult(new Integer(1));
          // Put exception message into log info instance.
          if (logInfo != null)
             logInfo.setExceptionMsg(fnfe.getMessage());
       }
       finally{
          // Log end date.
          if (log.isInfoEnabled())
             log.info("Script of '" + name + "' Quartz adapter has end. Stop time is: " + new Date());
       }
 
       // Save the log info instance
       if (logInfo != null){
          boolean done = saveLogInfoIfAvailable(logInfo);
       }
       return;
    }
 
 
    // Protected ----------------------------------------------------------------
 
    /**
     * This is a convenient method for retrieving a cron parameter value from context.
     * @param key The key of cron parameter to retrieve.
     * @param context The job context to retrieve parameter from
     * @return An object representing Quartz Cron parameter value
     */
    protected Object getParameterFromContext(String key, JobExecutionContext context){
       return context.getJobDetail().getJobDataMap().get(key);
    }
 
    /**
     * Configure this job instance using the {@link QuartzCronParameterInfo} that
     * may be present into the execution context. This may be necessary because when
     * launched by a scheduler, job instance is not directly available so configuration
     * parameters may be passed using the job details data map.
     * @param context
     * @throws InvalidParameterException
     */
    protected void configureJobFromContext(JobExecutionContext context) throws InvalidParameterException{
       Iterator values = context.getJobDetail().getJobDataMap().values().iterator();
       while (values != null && values.hasNext()){
          Object value = values.next();
          if (value instanceof QuartzCronParameterInfo){
             QuartzCronParameterInfo paramInfo = (QuartzCronParameterInfo)value;
             if (paramInfo.isJobParameter()){
                // Output some debug message before configuring job with this parameter.
                if (log.isDebugEnabled())
                   log.debug("Configuring the ScriptLauncher with: " + paramInfo.getName() + "[" + paramInfo.getValue() + "]");
                setParameter(paramInfo.getName(), paramInfo.getValue());
             }
          }
       }
    }
 }