package org.apache.onami.scheduler;

 /*

  * Licensed to the Apache Software Foundation (ASF) under one

  * or more contributor license agreements.  See the NOTICE file

  * distributed with this work for additional information

  * regarding copyright ownership.  The ASF licenses this file

  * to you under the Apache License, Version 2.0 (the

  * "License"); you may not use this file except in compliance

  * with the License.  You may obtain a copy of the License at

  *

  *   http://www.apache.org/licenses/LICENSE-2.0

  *

  * Unless required by applicable law or agreed to in writing,

  * software distributed under the License is distributed on an

  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

  * KIND, either express or implied.  See the License for the

  * specific language governing permissions and limitations

  * under the License.

  */

 import static com.google.inject.Scopes.SINGLETON;

 import static com.google.inject.multibindings.Multibinder.newSetBinder;

 import static java.util.TimeZone.getTimeZone;

 import static org.apache.onami.scheduler.Scheduled.DEFAULT;

 import java.util.TimeZone;

 import org.quartz.Job;

 import org.quartz.JobListener;

 import org.quartz.Scheduler;

 import org.quartz.SchedulerListener;

 import org.quartz.TriggerListener;

 import org.quartz.spi.JobFactory;

 import com.google.inject.AbstractModule;

 import com.google.inject.multibindings.Multibinder;

 /**

  * Quartz (http://www.quartz-scheduler.org/) Module as Google-Guice extension.

  */

 public abstract class QuartzModule

     extends AbstractModule

 {

     private Multibinder<JobListener> jobListeners;

     private Multibinder<TriggerListener> triggerListeners;

     private Multibinder<SchedulerListener> schedulerListeners;

         private SchedulerConfiguration schedulerConfiguration;

     /**

      * {@inheritDoc}

      */

     @Override

     protected final void configure()

     {

         checkState( jobListeners == null, "Re-entry is not allowed." );

         checkState( triggerListeners == null, "Re-entry is not allowed." );

         checkState( schedulerListeners == null, "Re-entry is not allowed." );

         checkState( schedulerConfiguration == null, "Re-entry is not allowed." );

         jobListeners = newSetBinder( binder(), JobListener.class );

         triggerListeners = newSetBinder( binder(), TriggerListener.class );

         schedulerListeners = newSetBinder( binder(), SchedulerListener.class );

         schedulerConfiguration = new SchedulerConfiguration();

         try

         {

             schedule();

             bind( JobFactory.class ).to( InjectorJobFactory.class ).in( SINGLETON );

             bind( Scheduler.class ).toProvider( SchedulerProvider.class ).asEagerSingleton();

             bind( SchedulerConfiguration.class ).toInstance( schedulerConfiguration );

         }

         finally

         {

             jobListeners = null;

             triggerListeners = null;

             schedulerListeners = null;

             schedulerConfiguration = null;

         }

     }

     /**

      * Part of the EDSL builder language for configuring {@code Job}s.

      * Here is a typical example of scheduling {@code Job}s when creating your Guice injector:

      *

      * <pre>

      * Guice.createInjector(..., new QuartzModule() {

      *

      *     {@literal @}Override

      *     protected void schedule() {

      *       <b>scheduleJob(MyJobImpl.class).withCronExpression("0/2 * * * * ?");</b>

      *     }

      *

      * });

      * </pre>

      *

      * @see JobSchedulerBuilder

      */

     protected abstract void schedule();

     /**

      * Allows to configure the scheduler.

      *

      * <pre>

      * Guice.createInjector(..., new QuartzModule() {

      *

      *     {@literal @}Override

      *     protected void schedule() {

      *       configureScheduler().withManualStart().withProperties(...);

      *     }

      *

      * });

      * </pre>

      *

      * @since 1.1

      */

     protected final SchedulerConfigurationBuilder configureScheduler()

     {

         return schedulerConfiguration;

     }

     /**

      * Add the {@code JobListener} binding.

      *

      * @param jobListenerType The {@code JobListener} class has to be bound

      */

     protected final void addJobListener( Class<? extends JobListener> jobListenerType )

     {

         doBind( jobListeners, jobListenerType );

     }

     /**

      * Add the {@code TriggerListener} binding.

      *

      * @param triggerListenerType The {@code TriggerListener} class has to be bound

      */

     protected final void addTriggerListener( Class<? extends TriggerListener> triggerListenerType )

     {

         doBind( triggerListeners, triggerListenerType );

     }

     /**

      * Add the {@code SchedulerListener} binding.

      *

      * @param schedulerListenerType The {@code SchedulerListener} class has to be bound

      */

     protected final void addSchedulerListener( Class<? extends SchedulerListener> schedulerListenerType )

     {

         doBind( schedulerListeners, schedulerListenerType );

     }

     /**

      * Allows {@code Job} scheduling, delegating Guice create the {@code Job} instance

      * and inject members.

      *

      * If given {@code Job} class is annotated with {@link Scheduled}, then {@code Job}

      * and related {@code Trigger} values will be extracted from it.

      *

      * @param jobClass The {@code Job} has to be scheduled

      * @return The {@code Job} builder

      */

     protected final JobSchedulerBuilder scheduleJob( Class<? extends Job> jobClass )

     {

         checkNotNull( jobClass, "Argument 'jobClass' must be not null." );

         JobSchedulerBuilder builder = new JobSchedulerBuilder( jobClass );

         if ( jobClass.isAnnotationPresent( Scheduled.class ) )

         {

             Scheduled scheduled = jobClass.getAnnotation( Scheduled.class );

             builder

             // job

             .withJobName( scheduled.jobName() )

             .withJobGroup( scheduled.jobGroup() )

             .withRequestRecovery( scheduled.requestRecovery() )

             .withStoreDurably( scheduled.storeDurably() )

             // trigger

             .withCronExpression( scheduled.cronExpression() )

             .withTriggerName( scheduled.triggerName() );

             if ( !DEFAULT.equals( scheduled.timeZoneId() ) )

             {

                 TimeZone timeZone = getTimeZone( scheduled.timeZoneId() );

                 if ( timeZone != null )

                 {

                     builder.withTimeZone( timeZone );

                 }

             }

         }

         requestInjection( builder );

         return builder;

     }

     /**

      * Utility method to respect the DRY principle.

      *

      * @param <T>

      * @param binder

      * @param type

      */

     protected final <T> void doBind( Multibinder<T> binder, Class<? extends T> type )

     {

         checkNotNull( type, "Impossible to bind a null type" );

         binder.addBinding().to( type );

     }

     private static void checkState( boolean state, String message )

     {

         if ( !state )

         {

             throw new IllegalStateException( message );

         }

     }

     private static void checkNotNull( Object object, String message )

     {

         if ( object == null )

         {

             throw new IllegalArgumentException( message );

         }

     }

 }