package foundation.schedule;

import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDataMap;
import org.quartz.JobDetail;
import org.quartz.JobExecutionException;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.SchedulerException;
import org.quartz.SchedulerFactory;
import org.quartz.Trigger;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.quartz.impl.StdSchedulerFactory;

import foundation.action.ActionContext;
import foundation.action.SingletonActionProvider;
import foundation.dao.DataReader;
import foundation.dao.DataWriter;
import foundation.server.config.Configer;
import foundation.util.Util;


public class ScheduleCenter extends SingletonActionProvider {
	
	public static boolean Test = false;
    public static boolean Terminated = false;
	protected static Logger logger;
	private static ScheduleCenter instance;
	private static Scheduler scheduler;
	private ScheduleBucket scheduleBucket;
	
	static {
		logger = LogManager.getLogger(ScheduleCenter.class);
		
	    try {
	    	String config = Configer.getPath_Config() + "schedule.properties";
	    	SchedulerFactory factory = new StdSchedulerFactory(config);
	    	scheduler = factory.getScheduler();	
		} 
	    catch (Exception e) {
	    	e.printStackTrace();
		}
	}

	public static synchronized ScheduleCenter getInstance() {
		if (instance == null) {
			instance = new ScheduleCenter();
		}
		
		return instance;
	}
	
	@Override
	protected void publishMethod() {
		//1. 启动定时任务
		addMethod("startup");
		
		//2. 停止定时任务
		addMethod("shutdown");
		
		//3. 暂停定时任务
		addMethod("pause");
		
		//4. 获取定时任务列表
		addMethod("getJobs");
		
		//5.根据JobName执行一次定时任务
		addMethod("executeJob");
		
		//6.保存Schedual
		addMethod("reloadSchedual");
		
		//7.根据JobName停止定时任务
		addMethod("pauseOneJob");
		
		//8.新增定时任务
		addMethod("appendOneJob");
		
	}

	public void startup() {
		if (scheduler == null) {
			return;
		}
		
	    try {
	    	Terminated = false;
	    	
			if (scheduler.isStarted()) {
				return;
			}
			
			scheduler.start();
		} 
	    catch (Exception e) {
			logger.error(e);
	    	e.printStackTrace();
		}
	}

	public void shutdown(ActionContext context) {
		if (scheduler == null) {
			return;
		}
		
		try {
	    	Terminated = true;
			scheduler.shutdown();
		}
		catch (Exception e) {
			logger.error(e);
	    	e.printStackTrace();
		}
	}
	
	public void pause(ActionContext context) {
		if (scheduler == null) {
			return;
		}
		
	    try {
	    	Terminated = false;
	    	
			if (!scheduler.isStarted()) {
				return;
			}
			
			scheduler.pauseAll();
		} 
	    catch (Exception e) {
			logger.error(e);
	    	e.printStackTrace();
		}
	}
	
	public void getJobs(ActionContext context) {
		DataWriter dataWriter = context.getDataWriter();
		dataWriter.addValue(scheduleBucket);
	}
	
	public void loadJobs(ScheduleBucket bucket) {
		if (scheduler == null) {
			return;
		}
		
	    try {
	    	//1. 如果已经启动，需要先关闭
			if (scheduler.isStarted()) {
				scheduler.shutdown();
			}
			
			//2. 如果已经加载，需要先清空
			scheduler.clear();

			//3. 保存 Bucket，将 Schedule Job 添加到 Quartz 中
			this.scheduleBucket = bucket;
			
			for (ScheduleBatch batch: bucket) {
				for (ScheduleJob job: batch) {
					appendOneJob(job);
				}
			}
		} 
	    catch (Exception e) {
			logger.error(e);
	    	e.printStackTrace();
		}
	}

 	public void reloadSchedual(ActionContext context) throws Exception {
		ScheduleLoader.load();
    }
	
	private void appendOneJob(ScheduleJob job) throws Exception {
		String runTime = job.getRunTime();
		
		if (runTime == null) {
			return;
		}
		
		JobKey jobKey = job.getJobKey();
	    JobDetail jobDetail = JobBuilder.newJob(ScheduleJobAgent.class).withIdentity(jobKey).build();
	    JobDataMap dataMap = jobDetail.getJobDataMap();
	    dataMap.put(job.getClass().getSimpleName(), job);
	    
	    TriggerKey triggerKey = job.getTriggerKey();
	    TriggerBuilder<Trigger> triggerBuilder = TriggerBuilder.newTrigger();
	    triggerBuilder.withIdentity(triggerKey);
	    triggerBuilder.withSchedule(CronScheduleBuilder.cronSchedule(runTime));
	    CronTrigger trigger = (CronTrigger)triggerBuilder.build();

	    if (!scheduler.checkExists(jobKey)) {
		    scheduler.scheduleJob(jobDetail, trigger);
	    }
	}

	public void executeJob(ActionContext context) throws JobExecutionException {
		DataReader dataReader = context.getDataReader();
		String scheduleId = dataReader.getString("scheduleId");
		String jobName = dataReader.getString("jobName");
		
		if (Util.isEmpty(scheduleId)) {
			logger.info("data not exists scheduleId, please check params");
		}
		
		ScheduleBatch scheduleBatch = scheduleBucket.get(scheduleId);
		
		if (Util.isEmpty(jobName)) {
			logger.info("data not exists jobName, will execute all job which scheduleId is " + scheduleId);
			
			for (ScheduleJob scheduleJob : scheduleBatch) {
				scheduleJob.execute();
			}
			
			return ;
		}
		
		for (ScheduleJob scheduleJob : scheduleBatch) {
			if (jobName.equalsIgnoreCase(scheduleJob.getId()) ) {
				scheduleJob.execute();
			}
		}
    }

 	public void pauseOneJob(ActionContext context) throws SchedulerException {
		DataReader dataReader = context.getDataReader();
		String scheduleId = dataReader.getString("scheduleId");
		String jobName = dataReader.getString("jobName");
		
		if (Util.isEmpty(scheduleId)) {
			logger.info("data not exists scheduleId, please check params");
		}
		
		ScheduleBatch scheduleBatch = scheduleBucket.get(scheduleId);
        
		if (Util.isEmpty(jobName)) {
			logger.info("data not exists jobName, will pause all job which scheduleId is " + scheduleId);
			
			for (ScheduleJob scheduleJob : scheduleBatch) {
				JobKey jobKey = scheduleJob.getJobKey();
		        scheduler.pauseJob(jobKey);
			}
			
			return ;
		}
		
		for (ScheduleJob scheduleJob : scheduleBatch) {
			if (jobName.equalsIgnoreCase(scheduleJob.getId()) ) {
				JobKey jobKey = scheduleJob.getJobKey();
		        scheduler.pauseJob(jobKey);
		        logger.info("pause scheduleId：{} ，jobName：{} ", scheduleId, jobName);
			}
			
		}
    }

}