quartz.scala

package cc.velosimple.loader.job

import org.quartz._
import org.quartz.impl.StdSchedulerFactory
import org.quartz.listeners.JobChainingJobListener
import org.quartz.JobBuilder._
import org.quartz.TriggerBuilder._
import org.quartz.CronScheduleBuilder._
import cc.velosimple.loader.Logger

object Main extends App with Quartz { 	
 	private lazy val log = Logger(getClass)

	override def main(args: Array[String]) {
		
		schedule {
			
			if (sys.props.contains("triggerOnStart")) 
				job(classOf[Loader]) withIdentity ("loader-now") now()
			
			job(classOf[Loader]) withIdentity ("loader-cron") at cronSchedule("0 0 4,16 * * ?")

		}

	}
}

trait Quartz {

	private val log = Logger(getClass)

	implicit def toJobDetail(jb: JobBuilder): JobDetail = jb.build

	implicit def toRichJob[JD <% JobDetail](job: JD) = new RichJob(job)

	implicit val scheduler = StdSchedulerFactory.getDefaultScheduler() 

	def job[T<:Job](clazz: Class[T]) = newJob(clazz)

	def schedule(fn: => Any) {
		try {
			fn
			scheduler.start()
	  } catch {
			case se: SchedulerException => 
				log.error(se)
				scheduler.shutdown()
		}
	}

	class RichJob(job: JobDetail) {

		def now()(implicit sched: Scheduler) = sched.scheduleJob(job, newTrigger().startNow().build())

		def at(trigger: Trigger)(implicit sched: Scheduler) = sched.scheduleJob(job, trigger)
	
		def ->(nextJob: JobDetail)(implicit sched: Scheduler) = {
			val jl = new JobChainingJobListener(job.getDescription)
			jl.addJobChainLink(job.getKey, nextJob.getKey)
			sched.getListenerManager().addJobListener(jl)
		}

		def at(builder: => CronScheduleBuilder)(implicit sched: Scheduler) {
			val trigger = newTrigger()
				.withSchedule(builder
					.withMisfireHandlingInstructionFireAndProceed())
				.build()
			sched.scheduleJob(job, trigger)
		}
	}

}