package quartz;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import jbo.sys.QUARTZ_MISSION_LIST;

import org.dom4j.Attribute;
import org.dom4j.Document;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.Trigger;
import org.quartz.Trigger.TriggerState;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;
import org.quartz.impl.matchers.GroupMatcher;
import com.amarsoft.are.jbo.JBOException;
import com.amarsoft.are.jbo.JBOFactory;
import com.amarsoft.are.jbo.JBOTransaction;


public class AutoExecuteMission implements ServletContextListener{
	private Scheduler scheduler;
	private String jobName;
	private String jobGroup;
	private String triggerName;
	private String triggerGroup;
	private String time;
	private String className;
	private String status;
	
	public String getStatus() {
		return status;
	}

	public void setStatus(String status) {
		this.status = status;
	}

	public String getClassName() {
		return className;
	}

	public void setClassName(String className) {
		this.className = className;
	}

	public String getTime() {
		return time;
	}

	public void setTime(String time) {
		this.time = time;
	}

	public String getJobName() {
		return jobName;
	}

	public void setJobName(String jobName) {
		this.jobName = jobName;
	}

	public String getJobGroup() {
		return jobGroup;
	}

	public void setJobGroup(String jobGroup) {
		this.jobGroup = jobGroup;
	}

	public String getTriggerName() {
		return triggerName;
	}

	public void setTriggerName(String triggerName) {
		this.triggerName = triggerName;
	}

	public String getTriggerGroup() {
		return triggerGroup;
	}

	public void setTriggerGroup(String triggerGroup) {
		this.triggerGroup = triggerGroup;
	}

	public AutoExecuteMission(){
//		SchedulerFactory sf = new StdSchedulerFactory();
		try {
			//构造一个定时器对象
			scheduler = StdSchedulerFactory.getDefaultScheduler();
		} catch (SchedulerException e) {
			e.printStackTrace();
		}
	}  

 /** 
  * 启动一个调度对象 
  * @throws SchedulerException 
  */  
 public  void start() throws SchedulerException  
 {   
	 //启动对象
     scheduler.start();  
 }  
   
 /** 
  * 检查调度是否启动 
  * @return 
  * @throws SchedulerException 
  */  
 public  boolean isStarted() throws SchedulerException  
 {  
	 //判断定时器是否已经启动
     return scheduler.isStarted();  
 }  

 /** 
  * 关闭调度信息 
  * @throws SchedulerException 
  */  
 public  void shutdown() throws SchedulerException   {  
	 //关闭定时器
     scheduler.shutdown();  
 }
 
 public String update(JBOTransaction tx){
	 try {
		 //获取定时器在数据库的相关数据
		int rows = JBOFactory.getBizObjectManager(QUARTZ_MISSION_LIST.CLASS_NAME)
			.createQuery("update O set mission_status=:Status where mission_id=:id")
				.setParameter("Status", status).setParameter("id", jobName).executeUpdate();
		if(rows>0){
			//判断定时器状态
			if("start".equals(status)){
				this.restartJob();
				TriggerState status = scheduler.getTriggerState(this.getCronTrigger().getKey());
				if("NORMAL".equals(status.toString())){
					return "1";//标识状态更新成功
				}
			}else if("pause".equals(status)){
				this.stopJob();
				TriggerState status = scheduler.getTriggerState(this.getCronTrigger().getKey());
				if("PAUSED".equals(status.toString())){
					return "1";//标识状态更新成功
				}
			}
		}
	} catch (Exception e) {
		e.printStackTrace();
	}
	 return "2";//表示状态更新失败
 }
 
 public JobDetail getJobDetail(){
	 Class c;
	 JobDetail jobDetail;
	try {
		c = Class.forName(className);
		jobDetail = JobBuilder.newJob(c).withIdentity(jobName, jobGroup).build();
		return jobDetail;
	} catch (ClassNotFoundException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
	return null;
 }
 
 public void updateTime(){
	 try {
		JBOFactory.getBizObjectManager(QUARTZ_MISSION_LIST.CLASS_NAME)
			.createQuery("update O set time=:Time where mission_id=:id").setParameter("Time", time)
				.setParameter("id", jobName).executeUpdate();
	} catch (JBOException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
 }
 
 public CronTrigger getCronTrigger(){
	//作业的触发器
     CronTrigger cronTrigger = TriggerBuilder.
                                 newTrigger().
                                 withIdentity(triggerName, triggerGroup).
                                 withSchedule(CronScheduleBuilder.cronSchedule(time)). //在任务调度器中，使用任务调度器的 CronScheduleBuilder 来生成一个具体的 CronTrigger 对象
                                 build(); 
     return cronTrigger;
 }
 
 public String createJob(JBOTransaction tx){
	try {
			scheduler.deleteJob(this.getJobDetail().getKey());	
			this.scheduleJob(this.getJobDetail(), getCronTrigger());
			//scheduler.triggerJob(this.getJobDetail().getKey());
			return this.update(tx);
		} catch (Exception e) {
			e.printStackTrace();
		}
	return "2";
 }
 
 public String executeMission(JBOTransaction tx){
	 try {
		 String now = String.valueOf(System.currentTimeMillis());
		 jobName = now;
		 jobGroup = now;
		 triggerName = now;
		 triggerGroup = now;
		 time = "1/10 * * * * ?";
		 //scheduler.deleteJob(getJobDetail().getKey());
		scheduler.scheduleJob(getJobDetail(), getCronTrigger());
		scheduler.triggerJob(getJobDetail().getKey());
		scheduler.start();
		scheduler.unscheduleJob(getCronTrigger().getKey());
		scheduler.deleteJob(getJobDetail().getKey());
		return "1";
	} catch (SchedulerException e) {
		e.printStackTrace();
	}
	 return "1";
 }
 
 public void whenServiceStart(){
	 try {
		this.scheduleJob(this.getJobDetail(), getCronTrigger());
	} catch (SchedulerException e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}
 }
 /** 
  * 添加调度的job信息 
  * @param jobdetail 
  * @param trigger 
  * @return 
  * @throws SchedulerException 
  */  
 public  Date scheduleJob(JobDetail jobdetail, Trigger trigger)  
         throws SchedulerException{  
             return scheduler.scheduleJob(jobdetail, trigger);   
 }  
 /** 
  * 添加相关的触发器 
  * @param trigger 
  * @return 
  * @throws SchedulerException 
  */  
 public  Date scheduleJob(Trigger trigger) throws SchedulerException{  
     return scheduler.scheduleJob(trigger);  
 }  
  /** 
   * 添加多个job任务 
   * @param triggersAndJobs 
   * @param replace 
   * @throws SchedulerException 
   */  
  public  void scheduleJobs(Map<JobDetail, Set<? extends Trigger>> triggersAndJobs, boolean replace) throws SchedulerException  
  {  
     scheduler.scheduleJobs(triggersAndJobs, replace);  
 }  
 /** 
  * 停止调度Job任务 
  * @param triggerkey 
  * @return 
  * @throws SchedulerException 
  */
  public void stopJob(){
	  try {
		this.pauseJob(this.getJobDetail().getKey());
		this.pauseTrigger(this.getCronTrigger().getKey());
	} catch (SchedulerException e) {
		e.printStackTrace();
	}
  }
  
 public  boolean unscheduleJob(TriggerKey triggerkey)  
         throws SchedulerException{  
     return scheduler.unscheduleJob(triggerkey);  
 }  

 /** 
  * 停止调度多个触发器相关的job 
  * @param list 
  * @return 
  * @throws SchedulerException 
  */  
 public  boolean unscheduleJobs(List<TriggerKey> triggerKeylist) throws SchedulerException{  
     return scheduler.unscheduleJobs(triggerKeylist);  
 }  
 /** 
  * 重新恢复触发器相关的job任务  
  * @param triggerkey 
  * @param trigger 
  * @return 
  * @throws SchedulerException 
  */  
 public  Date rescheduleJob(TriggerKey triggerkey, Trigger trigger)  
 throws SchedulerException{  
     return scheduler.rescheduleJob(triggerkey, trigger);  
 }  
 /** 
  * 添加相关的job任务 
  * @param jobdetail 
  * @param flag 
  * @throws SchedulerException 
  */  
 public  void addJob(JobDetail jobdetail, boolean flag)  
         throws SchedulerException   {  
     scheduler.addJob(jobdetail, flag);  
 }  

 /** 
  * 删除相关的job任务 
  * @param jobkey 
  * @return 
  * @throws SchedulerException 
  */  
 public  boolean deleteJob(JobKey jobkey) throws SchedulerException{  
     return scheduler.deleteJob(jobkey);  
 }  

 /** 
  * 删除相关的多个job任务 
  * @param jobKeys 
  * @return 
  * @throws SchedulerException 
  */  
 public     boolean deleteJobs(List<JobKey> jobKeys)  
 throws SchedulerException{  
     return scheduler.deleteJobs(jobKeys);  
 }  
 /**
  * 立即执行一次
  */
 public void startNow(){
	 try {
		this.triggerJob(this.getJobDetail().getKey());
	} catch (SchedulerException e) {
		e.printStackTrace();
	}
 }
 
 /** 
  *  
  * @param jobkey 
  * @throws SchedulerException 
  */  
 public  void triggerJob(JobKey jobkey) throws SchedulerException    {  
     scheduler.triggerJob(jobkey);  
 }  
 /** 
  *  
  * @param jobkey 
  * @param jobdatamap 
  * @throws SchedulerException 
  */  
 public  void triggerJob(JobKey jobkey, JobDataMap jobdatamap)  
         throws SchedulerException   {  
     scheduler.triggerJob(jobkey, jobdatamap);  
 }  
 /** 
  * 停止一个job任务 
  * @param jobkey 
  * @throws SchedulerException 
  */  
 public  void pauseJob(JobKey jobkey) throws SchedulerException  {  
     scheduler.pauseJob(jobkey);  
 }  
 /** 
  * 停止多个job任务 
  * @param groupmatcher 
  * @throws SchedulerException 
  */  
 public  void pauseJobs(GroupMatcher<JobKey> groupmatcher)  
         throws SchedulerException   {  
     scheduler.pauseJobs(groupmatcher);  
 }  
 /** 
  * 停止使用相关的触发器 
  * @param triggerkey 
  * @throws SchedulerException 
  */  
 public  void pauseTrigger(TriggerKey triggerkey)  
         throws SchedulerException   {  
     scheduler.pauseTrigger(triggerkey);  
 }  

 public  void pauseTriggers(GroupMatcher<TriggerKey> groupmatcher)  
         throws SchedulerException   {  
     scheduler.pauseTriggers(groupmatcher);  
 }  
 /** 
  * 恢复相关的job任务 
  * @param jobkey 
  * @throws SchedulerException 
  */  
 public void restartJob(){
	 try {
		 //删除已有的任务
		 scheduler.deleteJob(this.getJobDetail().getKey());
		 this.scheduleJob(this.getJobDetail(), this.getCronTrigger());
		 //在启动的同时执行一次定时任务
		 scheduler.triggerJob(this.getJobDetail().getKey());
	} catch (SchedulerException e) {
		e.printStackTrace();
	}
 }
 
 public  void resumeJob(JobKey jobkey) throws SchedulerException {  
     scheduler.resumeJob(jobkey);  
 }  
   
 public  void resumeJobs(GroupMatcher<JobKey> matcher)  
         throws SchedulerException   {  
     scheduler.resumeJobs(matcher);  
 }  

 public  void resumeTrigger(TriggerKey triggerkey)  
         throws SchedulerException   {  
     scheduler.resumeTrigger(triggerkey);  
 }  
  
 public  void resumeTriggers(GroupMatcher<TriggerKey>  groupmatcher)  
         throws SchedulerException  
 {  
     scheduler.resumeTriggers(groupmatcher);   
 }  
 /** 
  * 暂停调度中所有的job任务 
  * @throws SchedulerException 
  */  
 public  void pauseAll() throws SchedulerException  
 {  
     scheduler.pauseAll();  
 }  
 /** 
  * 恢复调度中所有的job的任务 
  * @throws SchedulerException 
  */  
 public  void resumeAll() throws SchedulerException  
 {  
     scheduler.resumeAll();  
 }

@Override
public void contextDestroyed(ServletContextEvent arg0) {
	try {
		scheduler.shutdown();
	} catch (SchedulerException e) {
		e.printStackTrace();
	}
}

@Override
public void contextInitialized(ServletContextEvent arg0) {
	Connection con = null;
	try {
		//启动定时任务
		scheduler.start();
		//获取JDBC驱动(因为JBO方法目前还未加载)
		Class.forName("com.mysql.jdbc.Driver");
		//创建XML阅读器
		SAXReader reader = new SAXReader();
		//获取当前JAVA的绝对路径
		String path = this.getClass().getResource("/").getPath().substring(1);
		//将路径转换为/META-INF/Context.xml
		path = path.substring(0, path.indexOf("/WEB-INF"));
		path = path+"/META-INF/Context.xml";
		Document doc = reader.read(path);
		//获得XML跟目录
		Element root = doc.getRootElement();
		//寻找标签
		Element el = root.element("Resource");
		//寻找标签属性
		Attribute attr = el.attribute("url");
		Attribute username = el.attribute("username");
		Attribute password = el.attribute("password");
		//获得连接
		String url = attr.getValue();
		String user = username.getValue();
		String pwd = password.getValue();
		//获取jdbc连接对象
		con = DriverManager.getConnection(url,user,pwd);
		//建立会话
		Statement stat = con.createStatement();
		//执行SQL
		ResultSet rs = stat.executeQuery("select * from quartz_mission_list");
		//遍历结果
		while(rs.next()){
			AutoExecuteMission aem = new AutoExecuteMission();
			aem.setJobName(rs.getString("mission_id"));
			aem.setJobGroup(rs.getString("mission_id"));
			aem.setTriggerName(rs.getString("mission_id"));
			aem.setTriggerGroup(rs.getString("mission_id"));
			aem.setTime(rs.getString("time"));
			aem.setClassName(rs.getString("mission_name"));
			String status = rs.getString("mission_status");
			if("start".equals(status)){
				//将原先正在执行的定时任务启动
				aem.scheduleJob(aem.getJobDetail(),aem.getCronTrigger());
			}else{
				//暂停的不做操作
//				aem.whenServiceStart();
//				aem.stopJob();
			}
		}
	} catch (Exception e) {
		// TODO Auto-generated catch block
		e.printStackTrace();
	}finally{
		if(con != null){
			try {
				//关闭连接
				con.close();
			} catch (SQLException e) {
				e.printStackTrace();
			}
		}
	}
	
} 
}