/**
    * This file Copyright (c) 2006-2011 Magnolia International
    * Ltd.  (http://www.magnolia-cms.com). All rights reserved.
    *
    *
    * This file is dual-licensed under both the Magnolia
    * Network Agreement and the GNU General Public License.
    * You may elect to use one or the other of these licenses.
    *
   * This file is distributed in the hope that it will be
   * useful, but AS-IS and WITHOUT ANY WARRANTY; without even the
   * implied warranty of MERCHANTABILITY or FITNESS FOR A
   * PARTICULAR PURPOSE, TITLE, or NONINFRINGEMENT.
   * Redistribution, except as permitted by whichever of the GPL
   * or MNA you select, is prohibited.
   *
   * 1. For the GPL license (GPL), you can redistribute and/or
   * modify this file under the terms of the GNU General
   * Public License, Version 3, as published by the Free Software
   * Foundation.  You should have received a copy of the GNU
   * General Public License, Version 3 along with this program;
   * if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
   *
   * 2. For the Magnolia Network Agreement (MNA), this file
   * and the accompanying materials are made available under the
   * terms of the MNA which accompanies this distribution, and
   * is available at http://www.magnolia-cms.com/mna.html
   *
   * Any modifications to this file must keep this entire header
   * intact.
   *
   */
  package info.magnolia.module.scheduler;
  
  import info.magnolia.module.ModuleLifecycle;
  import info.magnolia.module.ModuleLifecycleContext;
  
  import java.text.ParseException;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.commons.lang.StringUtils;
  import org.quartz.CronTrigger;
  import org.quartz.JobDetail;
  import org.quartz.Scheduler;
  import org.quartz.SchedulerException;
  import org.quartz.SchedulerFactory;
  import org.quartz.Trigger;
  import org.quartz.impl.StdSchedulerFactory;
  import org.slf4j.Logger;
  import org.slf4j.LoggerFactory;
  
  
  /**
   * Scheduler module. Under the node jobs one can create jobs by defining the command to use. The scheduling is done
   * based on a cron syntax scheduling expression. The job definition can contain a params node which can hold values
   * passed to the command in the execution-context.
   *
   * @author philipp
   * @version $Id$
   */
  public class SchedulerModule implements ModuleLifecycle {
      private static final Logger log = LoggerFactory.getLogger(JobDefinition.class);
  
      private static SchedulerModule instance;
  
      private List jobs = new ArrayList();
  
      private boolean running = false;
  
      /**
       * The quartz scheduler.
       */
      protected Scheduler scheduler;
  
      public SchedulerModule() {
          instance = this;
      }
  
  
      public List getJobs() {
          return this.jobs;
      }
  
  
      public void setJobs(List jobs) {
          this.jobs = jobs;
      }
  
      public void addJob(JobDefinition job) throws SchedulerException{
          jobs.add(job);
          if(running){
              initJob(job);
          }
      }
  
      /**
      * Stops the scheduler.
      */
     public void stop(ModuleLifecycleContext moduleLifecycleContext) {
         try {
             scheduler.shutdown(true);
             log.info("Waiting up to 30 seconds for scheduled jobs to stop...");
             int count = 0;
             while (count < 30) {
                 try {
                     Thread.sleep(1000);
                 } catch (InterruptedException e) {
                     Thread.interrupted();
                 }
                 if (scheduler.isShutdown()) {
                     break;
                 } else {
                     count++;
                 }
             }
             if (!scheduler.isShutdown()) {
                 log.info("Scheduled jobs failed to finish in 30 seconds interval, forcing shutdown now...");
                 scheduler.shutdown(false);
             }
             running = false;
         }
         catch (SchedulerException e) {
             log.error("Can't stop scheduler properly", e);
         }
     }
 
     /**
      * Start scheduler and add jobs.
      */
     public void start(ModuleLifecycleContext moduleLifecycleContext) {
         try {
             initScheduler();
             running = true;
         }
         catch (SchedulerException e) {
             log.error("Can't start scheduler", e);
             return;
         }
 
         initJobs();
     }
 
     /**
      * Add all the jobs defined in the jobs node.
      */
     protected void initJobs() {
         for (Iterator iter = jobs.iterator(); iter.hasNext();) {
             JobDefinition job = (JobDefinition) iter.next();
             try {
                 initJob(job);
             }
             catch (SchedulerException e) {
                 log.error("Can't initialize job [" + job.getName() + "]", e);
             }
         }
     }
 
     /**
      * Initialize a single job.
      */
     protected void initJob(JobDefinition job) throws SchedulerException {
         if (job.isActive()) {
             try {
                 stopJob(job.getName());
                 startJob(job);
             }
             catch (SchedulerException e) {
                 throw new SchedulerException("Can't schedule job" + job.getName(), e);
             }
         }
         else {
             try {
                 stopJob(job.getName());
             } catch (SchedulerException e) {
                 throw new SchedulerException("Can't delete inactive job " + job.getName(), e);
             }
         }
     }
 
     protected void startJob(JobDefinition job) throws SchedulerException {
         Trigger trigger;
         try {
             String cron = cronToQuarzCron(job.getCron());
             trigger = new CronTrigger(job.getName(), SchedulerConsts.SCHEDULER_GROUP_NAME, cron);
         }
         catch (ParseException e) {
             log.error("Can't parse the job's cron expression [" + job.getCron() + "]", e);
             return;
         }
 
         final Class jobClass = job.isConcurrent() ? CommandJob.class : StatefulCommandJob.class;
         final JobDetail jd = new JobDetail(job.getName(), SchedulerConsts.SCHEDULER_GROUP_NAME, jobClass);
         jd.getJobDataMap().put(SchedulerConsts.CONFIG_JOB_COMMAND, job.getCommand());
         jd.getJobDataMap().put(SchedulerConsts.CONFIG_JOB_COMMAND_CATALOG, job.getCatalog());
         jd.getJobDataMap().put(SchedulerConsts.CONFIG_JOB_PARAMS, job.getParams());
         scheduler.scheduleJob(jd, trigger);
         log.info("Job " + job.getName() + " added [" + job.getCron() + "]. Will fire first time at " + trigger.getNextFireTime());
     }
 
 
     protected String cronToQuarzCron(String cron) {
         // Quartz does not support * for both day of week and day of month. We simply handle this here.
         String[] tokens = StringUtils.split(cron);
         if (tokens.length >= 6) {
             if (!tokens[3].equals("?") && !tokens[5].equals("?")) {
                 if(tokens[5].equals("*")){
                     tokens[5] = "?";
                 }
                 else if(tokens[3].equals("*")){
                     tokens[3] = "?";
                 }
             }
         }
         cron = StringUtils.join(tokens, " ");
         return cron;
     }
 
     /**
      * Deletes the job safely. If the job is not defined, the method does NOT throw an exception.
      */
     public void stopJob(String name) throws SchedulerException {
         scheduler.deleteJob(name, SchedulerConsts.SCHEDULER_GROUP_NAME);
     }
 
     /**
      * Start the scheduler. No special configuration done yet.
      * @throws SchedulerException
      */
     protected void initScheduler() throws SchedulerException {
         SchedulerFactory sf = new StdSchedulerFactory();
         scheduler = sf.getScheduler();
         scheduler.start();
     }
 
     /**
      * If you need to get the scheduler handled by the module.
      */
     public Scheduler getScheduler() {
         return scheduler;
     }
 
     /**
      * Singleton instance of the module.
      */
     public static SchedulerModule getInstance() {
         return instance;
     }
 
 }