package org.apache.openejb.quartz.core;

import static org.apache.openejb.quartz.JobKey.jobKey;
import static org.apache.openejb.quartz.TriggerKey.triggerKey;

import java.beans.BeanInfo;
import java.beans.IntrospectionException;
import java.beans.Introspector;
import java.beans.MethodDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.text.ParseException;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.atomic.AtomicLong;

import javax.management.ListenerNotFoundException;
import javax.management.MBeanNotificationInfo;
import javax.management.NotCompliantMBeanException;
import javax.management.Notification;
import javax.management.NotificationBroadcasterSupport;
import javax.management.NotificationEmitter;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.StandardMBean;
import javax.management.openmbean.CompositeData;
import javax.management.openmbean.TabularData;

import org.apache.openejb.quartz.JobDataMap;
import org.apache.openejb.quartz.JobDetail;
import org.apache.openejb.quartz.JobExecutionContext;
import org.apache.openejb.quartz.JobExecutionException;
import org.apache.openejb.quartz.JobKey;
import org.apache.openejb.quartz.JobListener;
import org.apache.openejb.quartz.SchedulerException;
import org.apache.openejb.quartz.SchedulerListener;
import org.apache.openejb.quartz.Trigger;
import org.apache.openejb.quartz.Trigger.TriggerState;
import org.apache.openejb.quartz.TriggerKey;
import org.apache.openejb.quartz.core.jmx.JobDetailSupport;
import org.apache.openejb.quartz.core.jmx.JobExecutionContextSupport;
import org.apache.openejb.quartz.core.jmx.QuartzSchedulerMBean;
import org.apache.openejb.quartz.core.jmx.TriggerSupport;
import org.apache.openejb.quartz.impl.matchers.GroupMatcher;
import org.apache.openejb.quartz.impl.triggers.AbstractTrigger;
import org.apache.openejb.quartz.spi.OperableTrigger;

public class QuartzSchedulerMBeanImpl extends StandardMBean implements
        NotificationEmitter, QuartzSchedulerMBean, JobListener,
        SchedulerListener {
    private static final MBeanNotificationInfo[] NOTIFICATION_INFO;

    private final QuartzScheduler scheduler;
    private boolean sampledStatisticsEnabled;
    private SampledStatistics sampledStatistics;

    private final static SampledStatistics NULL_SAMPLED_STATISTICS = new NullSampledStatisticsImpl();

    static {
        final String[] notifTypes = new String[] { SCHEDULER_STARTED,
                SCHEDULER_PAUSED, SCHEDULER_SHUTDOWN, };
        final String name = Notification.class.getName();
        final String description = "QuartzScheduler JMX Event";
        NOTIFICATION_INFO = new MBeanNotificationInfo[] { new MBeanNotificationInfo(
                notifTypes, name, description), };
    }

    /**
     * emitter
     */
    protected final Emitter emitter = new Emitter();

    /**
     * sequenceNumber
     */
    protected final AtomicLong sequenceNumber = new AtomicLong();

    /**
     * QuartzSchedulerMBeanImpl
     *
     * @throws NotCompliantMBeanException
     */
    protected QuartzSchedulerMBeanImpl(QuartzScheduler scheduler)
            throws NotCompliantMBeanException {
        super(QuartzSchedulerMBean.class);
        this.scheduler = scheduler;
        this.scheduler.addInternalJobListener(this);
        this.scheduler.addInternalSchedulerListener(this);
        this.sampledStatistics = NULL_SAMPLED_STATISTICS;
        this.sampledStatisticsEnabled = false;
    }

    public TabularData getCurrentlyExecutingJobs() throws Exception {
        try {
            List<JobExecutionContext> currentlyExecutingJobs = scheduler.getCurrentlyExecutingJobs();
            return JobExecutionContextSupport.toTabularData(currentlyExecutingJobs);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public TabularData getAllJobDetails() throws Exception {
        try {
            List<JobDetail> detailList = new ArrayList<JobDetail>();
            for (String jobGroupName : scheduler.getJobGroupNames()) {
                for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(jobGroupName))) {
                    detailList.add(scheduler.getJobDetail(jobKey));
                }
            }
            return JobDetailSupport.toTabularData(detailList.toArray(new JobDetail[detailList.size()]));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public List<CompositeData> getAllTriggers() throws Exception {
        try {
            List<Trigger> triggerList = new ArrayList<Trigger>();
            for (String triggerGroupName : scheduler.getTriggerGroupNames()) {
                for (TriggerKey triggerKey : scheduler.getTriggerKeys(GroupMatcher.triggerGroupEquals(triggerGroupName))) {
                    triggerList.add(scheduler.getTrigger(triggerKey));
                }
            }
            return TriggerSupport.toCompositeList(triggerList);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void addJob(CompositeData jobDetail, boolean replace) throws Exception {
        try {
            scheduler.addJob(JobDetailSupport.newJobDetail(jobDetail), replace);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    private static void invokeSetter(Object target, String attribute, Object value) throws Exception {
        String setterName = "set" + Character.toUpperCase(attribute.charAt(0)) + attribute.substring(1);
        Class<?>[] argTypes = {value.getClass()};
        Method setter = findMethod(target.getClass(), setterName, argTypes);
        if(setter != null) {
            setter.invoke(target, value);
        } else {
            throw new Exception("Unable to find setter for attribute '" + attribute
                    + "' and value '" + value + "'");
        }
    }

    private static Class<?> getWrapperIfPrimitive(Class<?> c) {
        Class<?> result = c;
        try {
            Field f = c.getField("TYPE");
            f.setAccessible(true);
            result = (Class<?>) f.get(null);
        } catch (Exception e) {
            /**/
        }
        return result;
    }

    private static Method findMethod(Class<?> targetType, String methodName,
            Class<?>[] argTypes) throws IntrospectionException {
        BeanInfo beanInfo = Introspector.getBeanInfo(targetType);
        if (beanInfo != null) {
            for(MethodDescriptor methodDesc: beanInfo.getMethodDescriptors()) {
                Method method = methodDesc.getMethod();
                Class<?>[] parameterTypes = method.getParameterTypes();
                if (methodName.equals(method.getName()) && argTypes.length == parameterTypes.length) {
                    boolean matchedArgTypes = true;
                    for (int i = 0; i < argTypes.length; i++) {
                        if (getWrapperIfPrimitive(argTypes[i]) != parameterTypes[i]) {
                            matchedArgTypes = false;
                            break;
                        }
                    }
                    if (matchedArgTypes) {
                        return method;
                    }
                }
            }
        }
        return null;
    }

    public void scheduleBasicJob(Map<String, Object> jobDetailInfo,
            Map<String, Object> triggerInfo) throws Exception {
        try {
            JobDetail jobDetail = JobDetailSupport.newJobDetail(jobDetailInfo);
            OperableTrigger trigger = TriggerSupport.newTrigger(triggerInfo);
            scheduler.deleteJob(jobDetail.getKey());
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (ParseException pe) {
            throw pe;
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void scheduleJob(Map<String, Object> abstractJobInfo,
            Map<String, Object> abstractTriggerInfo) throws Exception {
        try {
            String triggerClassName = (String) abstractTriggerInfo.remove("triggerClass");
            if(triggerClassName == null) {
                throw new IllegalArgumentException("No triggerClass specified");
            }
            Class<?> triggerClass = Class.forName(triggerClassName);
            Trigger trigger = (Trigger) triggerClass.newInstance();

            String jobDetailClassName = (String) abstractJobInfo.remove("jobDetailClass");
            if(jobDetailClassName == null) {
                throw new IllegalArgumentException("No jobDetailClass specified");
            }
            Class<?> jobDetailClass = Class.forName(jobDetailClassName);
            JobDetail jobDetail = (JobDetail) jobDetailClass.newInstance();

            String jobClassName = (String) abstractJobInfo.remove("jobClass");
            if(jobClassName == null) {
                throw new IllegalArgumentException("No jobClass specified");
            }
            Class<?> jobClass = Class.forName(jobClassName);
            abstractJobInfo.put("jobClass", jobClass);

            for(Map.Entry<String, Object> entry : abstractTriggerInfo.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();
                if("jobDataMap".equals(key)) {
                    value = new JobDataMap((Map<?, ?>)value);
                }
                invokeSetter(trigger, key, value);
            }

            for(Map.Entry<String, Object> entry : abstractJobInfo.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();
                if("jobDataMap".equals(key)) {
                    value = new JobDataMap((Map<?, ?>)value);
                }
                invokeSetter(jobDetail, key, value);
            }

            AbstractTrigger<?> at = (AbstractTrigger<?>)trigger;
            at.setKey(new TriggerKey(at.getName(), at.getGroup()));

            Date startDate = at.getStartTime();
            if(startDate == null || startDate.before(new Date())) {
                at.setStartTime(new Date());
            }

            scheduler.deleteJob(jobDetail.getKey());
            scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void scheduleJob(String jobName, String jobGroup,
            Map<String, Object> abstractTriggerInfo) throws Exception {
        try {
            JobKey jobKey = new JobKey(jobName, jobGroup);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if(jobDetail == null) {
                throw new IllegalArgumentException("No such job '" + jobKey + "'");
            }

            String triggerClassName = (String) abstractTriggerInfo.remove("triggerClass");
            if(triggerClassName == null) {
                throw new IllegalArgumentException("No triggerClass specified");
            }
            Class<?> triggerClass = Class.forName(triggerClassName);
            Trigger trigger = (Trigger) triggerClass.newInstance();

            for(Map.Entry<String, Object> entry : abstractTriggerInfo.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();
                if("jobDataMap".equals(key)) {
                    value = new JobDataMap((Map<?, ?>)value);
                }
                invokeSetter(trigger, key, value);
            }

            AbstractTrigger<?> at = (AbstractTrigger<?>)trigger;
            at.setKey(new TriggerKey(at.getName(), at.getGroup()));

            Date startDate = at.getStartTime();
            if(startDate == null || startDate.before(new Date())) {
                at.setStartTime(new Date());
            }

            scheduler.scheduleJob(trigger);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void addJob(Map<String, Object> abstractJobInfo,    boolean replace) throws Exception {
        try {
            String jobDetailClassName = (String) abstractJobInfo.remove("jobDetailClass");
            if(jobDetailClassName == null) {
                throw new IllegalArgumentException("No jobDetailClass specified");
            }
            Class<?> jobDetailClass = Class.forName(jobDetailClassName);
            JobDetail jobDetail = (JobDetail) jobDetailClass.newInstance();

            String jobClassName = (String) abstractJobInfo.remove("jobClass");
            if(jobClassName == null) {
                throw new IllegalArgumentException("No jobClass specified");
            }
            Class<?> jobClass = Class.forName(jobClassName);
            abstractJobInfo.put("jobClass", jobClass);

            for(Map.Entry<String, Object> entry : abstractJobInfo.entrySet()) {
                String key = entry.getKey();
                Object value = entry.getValue();
                if("jobDataMap".equals(key)) {
                    value = new JobDataMap((Map<?, ?>)value);
                }
                invokeSetter(jobDetail, key, value);
            }

            scheduler.addJob(jobDetail, replace);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    private Exception newPlainException(Exception e) {
        String type = e.getClass().getName();
        if(type.startsWith("java.") || type.startsWith("javax.") || type.startsWith("jakarta.")) {
            return e;
        } else {
            Exception result = new Exception(e.getMessage());
            result.setStackTrace(e.getStackTrace());
            return result;
        }
    }

    public void deleteCalendar(String calendarName) throws Exception {
        try {
            scheduler.deleteCalendar(calendarName);
        } catch(Exception e) {
            throw newPlainException(e);
        }
    }

    public boolean deleteJob(String jobName, String jobGroupName) throws Exception {
        try {
            return scheduler.deleteJob(jobKey(jobName, jobGroupName));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public List<String> getCalendarNames()    throws Exception {
        try {
            return scheduler.getCalendarNames();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public CompositeData getJobDetail(String jobName, String jobGroupName)
      throws Exception {
        try {
            JobDetail jobDetail = scheduler.getJobDetail(jobKey(jobName, jobGroupName));
            return JobDetailSupport.toCompositeData(jobDetail);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public List<String> getJobGroupNames()    throws Exception {
        try {
            return scheduler.getJobGroupNames();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public List<String> getJobNames(String groupName) throws Exception {
        try {
            List<String> jobNames = new ArrayList<String>();
            for(JobKey key: scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
                jobNames.add(key.getName());
            }
            return jobNames;
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public String getJobStoreClassName() {
        return scheduler.getJobStoreClass().getName();
    }

    public Set<String> getPausedTriggerGroups() throws Exception {
        try {
            return scheduler.getPausedTriggerGroups();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public CompositeData getTrigger(String name, String groupName) throws Exception {
        try {
            Trigger trigger = scheduler.getTrigger(triggerKey(name, groupName));
            return TriggerSupport.toCompositeData(trigger);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public List<String> getTriggerGroupNames()    throws Exception {
        try {
            return scheduler.getTriggerGroupNames();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public List<String> getTriggerNames(String groupName) throws Exception {
        try {
            List<String> triggerNames = new ArrayList<String>();
            for(TriggerKey key: scheduler.getTriggerKeys(GroupMatcher.triggerGroupEquals(groupName))) {
                triggerNames.add(key.getName());
            }
            return triggerNames;
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public String getTriggerState(String triggerName, String triggerGroupName) throws Exception {
        try {
            TriggerKey triggerKey = triggerKey(triggerName, triggerGroupName);
            TriggerState ts = scheduler.getTriggerState(triggerKey);
            return ts.name();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public List<CompositeData> getTriggersOfJob(String jobName, String jobGroupName) throws Exception {
        try {
            JobKey jobKey = jobKey(jobName, jobGroupName);
            return TriggerSupport.toCompositeList(scheduler.getTriggersOfJob(jobKey));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public boolean interruptJob(String jobName, String jobGroupName) throws Exception {
        try {
            return scheduler.interrupt(jobKey(jobName, jobGroupName));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public boolean interruptJob(String fireInstanceId) throws Exception {
        try {
            return scheduler.interrupt(fireInstanceId);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public Date scheduleJob(String jobName, String jobGroup,
            String triggerName, String triggerGroup) throws Exception {
        try {
            JobKey jobKey = jobKey(jobName, jobGroup);
            JobDetail jobDetail = scheduler.getJobDetail(jobKey);
            if (jobDetail == null) {
                throw new IllegalArgumentException("No such job: " + jobKey);
            }
            TriggerKey triggerKey = triggerKey(triggerName, triggerGroup);
            Trigger trigger = scheduler.getTrigger(triggerKey);
            if (trigger == null) {
                throw new IllegalArgumentException("No such trigger: " + triggerKey);
            }
            return scheduler.scheduleJob(jobDetail, trigger);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public boolean unscheduleJob(String triggerName, String triggerGroup) throws Exception {
        try {
            return scheduler.unscheduleJob(triggerKey(triggerName, triggerGroup));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

   public void clear() throws Exception {
       try {
           scheduler.clear();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public String getVersion() {
        return scheduler.getVersion();
    }

    public boolean isShutdown() {
        return scheduler.isShutdown();
    }

    public boolean isStarted() {
        return scheduler.isStarted();
    }

    public void start() throws Exception {
        try {
            scheduler.start();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void shutdown() {
        scheduler.shutdown();
    }

    public void standby() {
        scheduler.standby();
    }

    public boolean isStandbyMode() {
        return scheduler.isInStandbyMode();
    }

    public String getSchedulerName() {
        return scheduler.getSchedulerName();
    }

    public String getSchedulerInstanceId() {
        return scheduler.getSchedulerInstanceId();
    }

    public String getThreadPoolClassName() {
        return scheduler.getThreadPoolClass().getName();
    }

    public int getThreadPoolSize() {
        return scheduler.getThreadPoolSize();
    }

    public void pauseJob(String jobName, String jobGroup) throws Exception {
        try {
            scheduler.pauseJob(jobKey(jobName, jobGroup));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void pauseJobs(GroupMatcher<JobKey> matcher) throws Exception {
        try {
            scheduler.pauseJobs(matcher);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void pauseJobGroup(String jobGroup) throws Exception {
        pauseJobs(GroupMatcher.<JobKey>groupEquals(jobGroup));
    }

    public void pauseJobsStartingWith(String jobGroupPrefix) throws Exception {
        pauseJobs(GroupMatcher.<JobKey>groupStartsWith(jobGroupPrefix));
    }

    public void pauseJobsEndingWith(String jobGroupSuffix) throws Exception {
        pauseJobs(GroupMatcher.<JobKey>groupEndsWith(jobGroupSuffix));
    }

    public void pauseJobsContaining(String jobGroupToken) throws Exception {
        pauseJobs(GroupMatcher.<JobKey>groupContains(jobGroupToken));
    }

    public void pauseJobsAll() throws Exception {
        pauseJobs(GroupMatcher.anyJobGroup());
    }

    public void pauseAllTriggers() throws Exception {
        try {
            scheduler.pauseAll();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    private void pauseTriggers(GroupMatcher<TriggerKey> matcher) throws Exception {
        try {
            scheduler.pauseTriggers(matcher);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void pauseTriggerGroup(String triggerGroup) throws Exception {
        pauseTriggers(GroupMatcher.<TriggerKey>groupEquals(triggerGroup));
    }

    public void pauseTriggersStartingWith(String triggerGroupPrefix) throws Exception {
        pauseTriggers(GroupMatcher.<TriggerKey>groupStartsWith(triggerGroupPrefix));
    }

    public void pauseTriggersEndingWith(String triggerGroupSuffix) throws Exception {
        pauseTriggers(GroupMatcher.<TriggerKey>groupEndsWith(triggerGroupSuffix));
    }

    public void pauseTriggersContaining(String triggerGroupToken) throws Exception {
        pauseTriggers(GroupMatcher.<TriggerKey>groupContains(triggerGroupToken));
    }

    public void pauseTriggersAll() throws Exception {
        pauseTriggers(GroupMatcher.anyTriggerGroup());
    }

    public void pauseTrigger(String triggerName, String triggerGroup) throws Exception {
        try {
            scheduler.pauseTrigger(triggerKey(triggerName, triggerGroup));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void resumeAllTriggers() throws Exception {
        try {
            scheduler.resumeAll();
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void resumeJob(String jobName, String jobGroup) throws Exception {
        try {
            scheduler.resumeJob(jobKey(jobName, jobGroup));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void resumeJobs(GroupMatcher<JobKey> matcher) throws Exception {
        try {
            scheduler.resumeJobs(matcher);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void resumeJobGroup(String jobGroup) throws Exception {
        resumeJobs(GroupMatcher.<JobKey>groupEquals(jobGroup));
    }

    public void resumeJobsStartingWith(String jobGroupPrefix) throws Exception {
        resumeJobs(GroupMatcher.<JobKey>groupStartsWith(jobGroupPrefix));
    }

    public void resumeJobsEndingWith(String jobGroupSuffix) throws Exception {
        resumeJobs(GroupMatcher.<JobKey>groupEndsWith(jobGroupSuffix));
    }

    public void resumeJobsContaining(String jobGroupToken) throws Exception {
        resumeJobs(GroupMatcher.<JobKey>groupContains(jobGroupToken));
    }

    public void resumeJobsAll() throws Exception {
        resumeJobs(GroupMatcher.anyJobGroup());
    }

    public void resumeTrigger(String triggerName, String triggerGroup) throws Exception {
        try {
            scheduler.resumeTrigger(triggerKey(triggerName, triggerGroup));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    private void resumeTriggers(GroupMatcher<TriggerKey> matcher) throws Exception {
        try {
            scheduler.resumeTriggers(matcher);
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void resumeTriggerGroup(String triggerGroup) throws Exception {
        resumeTriggers(GroupMatcher.<TriggerKey>groupEquals(triggerGroup));
    }

    public void resumeTriggersStartingWith(String triggerGroupPrefix) throws Exception {
        resumeTriggers(GroupMatcher.<TriggerKey>groupStartsWith(triggerGroupPrefix));
    }

    public void resumeTriggersEndingWith(String triggerGroupSuffix) throws Exception {
        resumeTriggers(GroupMatcher.<TriggerKey>groupEndsWith(triggerGroupSuffix));
    }

    public void resumeTriggersContaining(String triggerGroupToken) throws Exception {
        resumeTriggers(GroupMatcher.<TriggerKey>groupContains(triggerGroupToken));
    }

    public void resumeTriggersAll() throws Exception {
        resumeTriggers(GroupMatcher.anyTriggerGroup());
    }

    public void triggerJob(String jobName, String jobGroup, Map<String, String> jobDataMap)
            throws Exception {
        try {
            scheduler.triggerJob(jobKey(jobName, jobGroup), new JobDataMap(jobDataMap));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    public void triggerJob(CompositeData trigger) throws Exception {
        try {
            scheduler.triggerJob(TriggerSupport.newTrigger(trigger));
        } catch (Exception e) {
            throw newPlainException(e);
        }
    }

    // ScheduleListener

    public void jobAdded(JobDetail jobDetail) {
        sendNotification(JOB_ADDED, JobDetailSupport.toCompositeData(jobDetail));
    }

    public void jobDeleted(JobKey jobKey) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("jobName", jobKey.getName());
        map.put("jobGroup", jobKey.getGroup());
        sendNotification(JOB_DELETED, map);
    }

    public void jobScheduled(Trigger trigger) {
        sendNotification(JOB_SCHEDULED, TriggerSupport.toCompositeData(trigger));
    }

    public void jobUnscheduled(TriggerKey triggerKey) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("triggerName", triggerKey.getName());
        map.put("triggerGroup", triggerKey.getGroup());
        sendNotification(JOB_UNSCHEDULED, map);
    }

    public void schedulingDataCleared() {
        sendNotification(SCHEDULING_DATA_CLEARED);
    }

    public void jobPaused(JobKey jobKey) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("jobName", jobKey.getName());
        map.put("jobGroup", jobKey.getGroup());
        sendNotification(JOBS_PAUSED, map);
    }

    public void jobsPaused(String jobGroup) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("jobName", null);
        map.put("jobGroup", jobGroup);
        sendNotification(JOBS_PAUSED, map);
    }

    public void jobsResumed(String jobGroup) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("jobName", null);
        map.put("jobGroup", jobGroup);
        sendNotification(JOBS_RESUMED, map);
    }

    public void jobResumed(JobKey jobKey) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("jobName", jobKey.getName());
        map.put("jobGroup", jobKey.getGroup());
        sendNotification(JOBS_RESUMED, map);
    }

    public void schedulerError(String msg, SchedulerException cause) {
        sendNotification(SCHEDULER_ERROR, cause.getMessage());
    }

    public void schedulerStarted() {
        sendNotification(SCHEDULER_STARTED);
    }

    //not doing anything, just like schedulerShuttingdown
    public void schedulerStarting() {
    }

    public void schedulerInStandbyMode() {
        sendNotification(SCHEDULER_PAUSED);
    }

    public void schedulerShutdown() {
        scheduler.removeInternalSchedulerListener(this);
        scheduler.removeInternalJobListener(getName());

        sendNotification(SCHEDULER_SHUTDOWN);
    }

    public void schedulerShuttingdown() {
    }

    public void triggerFinalized(Trigger trigger) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("triggerName", trigger.getKey().getName());
        map.put("triggerGroup", trigger.getKey().getGroup());
        sendNotification(TRIGGER_FINALIZED, map);
    }

    public void triggersPaused(String triggerGroup) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("triggerName", null);
        map.put("triggerGroup", triggerGroup);
        sendNotification(TRIGGERS_PAUSED, map);
    }

    public void triggerPaused(TriggerKey triggerKey) {
        Map<String, String> map = new HashMap<String, String>();
        if(triggerKey != null) {
            map.put("triggerName", triggerKey.getName());
            map.put("triggerGroup", triggerKey.getGroup());
        }
        sendNotification(TRIGGERS_PAUSED, map);
    }

    public void triggersResumed(String triggerGroup) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("triggerName", null);
        map.put("triggerGroup", triggerGroup);
        sendNotification(TRIGGERS_RESUMED, map);
    }

    public void triggerResumed(TriggerKey triggerKey) {
        Map<String, String> map = new HashMap<String, String>();
        if(triggerKey != null) {
            map.put("triggerName", triggerKey.getName());
            map.put("triggerGroup", triggerKey.getGroup());
        }
        sendNotification(TRIGGERS_RESUMED, map);
    }

    // JobListener

    public String getName() {
        return "QuartzSchedulerMBeanImpl.listener";
    }

    public void jobExecutionVetoed(JobExecutionContext context) {
        try {
            sendNotification(JOB_EXECUTION_VETOED, JobExecutionContextSupport
                    .toCompositeData(context));
        } catch (Exception e) {
            throw new RuntimeException(newPlainException(e));
        }
    }

    public void jobToBeExecuted(JobExecutionContext context) {
        try {
            sendNotification(JOB_TO_BE_EXECUTED, JobExecutionContextSupport
                    .toCompositeData(context));
        } catch (Exception e) {
            throw new RuntimeException(newPlainException(e));
        }
    }

    public void jobWasExecuted(JobExecutionContext context,
            JobExecutionException jobException) {
        try {
            sendNotification(JOB_WAS_EXECUTED, JobExecutionContextSupport
                    .toCompositeData(context));
        } catch (Exception e) {
            throw new RuntimeException(newPlainException(e));
        }
    }

    // NotificationBroadcaster

    /**
     * sendNotification
     *
     * @param eventType
     */
    public void sendNotification(String eventType) {
        sendNotification(eventType, null, null);
    }

    /**
     * sendNotification
     *
     * @param eventType
     * @param data
     */
    public void sendNotification(String eventType, Object data) {
        sendNotification(eventType, data, null);
    }

    /**
     * sendNotification
     *
     * @param eventType
     * @param data
     * @param msg
     */
    public void sendNotification(String eventType, Object data, String msg) {
        Notification notif = new Notification(eventType, this, sequenceNumber
                .incrementAndGet(), System.currentTimeMillis(), msg);
        if (data != null) {
            notif.setUserData(data);
        }
        emitter.sendNotification(notif);
    }

    /**
     * @author gkeim
     */
    private class Emitter extends NotificationBroadcasterSupport {
        /**
         * @see javax.management.NotificationBroadcasterSupport#getNotificationInfo()
         */
        @Override
        public MBeanNotificationInfo[] getNotificationInfo() {
            return QuartzSchedulerMBeanImpl.this.getNotificationInfo();
        }
    }

    /**
     * @see javax.management.NotificationBroadcaster#addNotificationListener(javax.management.NotificationListener,
     *      javax.management.NotificationFilter, java.lang.Object)
     */
    public void addNotificationListener(NotificationListener notif,
            NotificationFilter filter, Object callBack) {
        emitter.addNotificationListener(notif, filter, callBack);
    }

    /**
     * @see javax.management.NotificationBroadcaster#getNotificationInfo()
     */
    public MBeanNotificationInfo[] getNotificationInfo() {
        return NOTIFICATION_INFO;
    }

    /**
     * @see javax.management.NotificationBroadcaster#removeNotificationListener(javax.management.NotificationListener)
     */
    public void removeNotificationListener(NotificationListener listener)
            throws ListenerNotFoundException {
        emitter.removeNotificationListener(listener);
    }

    /**
     * @see javax.management.NotificationEmitter#removeNotificationListener(javax.management.NotificationListener,
     *      javax.management.NotificationFilter, java.lang.Object)
     */
    public void removeNotificationListener(NotificationListener notif,
            NotificationFilter filter, Object callBack)
            throws ListenerNotFoundException {
        emitter.removeNotificationListener(notif, filter, callBack);
    }

    public synchronized boolean isSampledStatisticsEnabled() {
        return sampledStatisticsEnabled;
    }

    public void setSampledStatisticsEnabled(boolean enabled) {
        if (enabled != this.sampledStatisticsEnabled) {
            this.sampledStatisticsEnabled = enabled;
            if(enabled) {
                this.sampledStatistics = new SampledStatisticsImpl(scheduler);
            }
            else {
                 this.sampledStatistics.shutdown();
                 this.sampledStatistics = NULL_SAMPLED_STATISTICS;
            }
            sendNotification(SAMPLED_STATISTICS_ENABLED, Boolean.valueOf(enabled));
        }
    }

    public long getJobsCompletedMostRecentSample() {
        return this.sampledStatistics.getJobsCompletedMostRecentSample();
    }

    public long getJobsExecutedMostRecentSample() {
        return this.sampledStatistics.getJobsExecutingMostRecentSample();
    }

    public long getJobsScheduledMostRecentSample() {
        return this.sampledStatistics.getJobsScheduledMostRecentSample();
    }

    public Map<String, Long> getPerformanceMetrics() {
        Map<String, Long> result = new HashMap<String, Long>();
        result.put("JobsCompleted", Long
                .valueOf(getJobsCompletedMostRecentSample()));
        result.put("JobsExecuted", Long
                .valueOf(getJobsExecutedMostRecentSample()));
        result.put("JobsScheduled", Long
                .valueOf(getJobsScheduledMostRecentSample()));
        return result;
    }
}
