/*
    Copyright 2008 Ramon Servadei
   
    Licensed 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.
   */
  package fulmine.event.listener;
  
  import static fulmine.util.Utils.logException;
  
  import java.lang.reflect.ParameterizedType;
  import java.lang.reflect.TypeVariable;
  import java.util.Arrays;
  import java.util.Map;
  
  import fulmine.event.EventProcessor;
  import fulmine.event.IEvent;
  import fulmine.event.IEventManager;
  import fulmine.event.IEventSource;
  import fulmine.util.collection.CollectionFactory;
  import fulmine.util.collection.CollectionUtils;
  import fulmine.util.log.AsyncLog;
  import fulmine.util.reference.AutoCreatingStore;
  import fulmine.util.reference.IAutoCreatingStore;
  import fulmine.util.reference.IObjectBuilder;
  
  /**
   * Base class for an object that handles a specific type of {@link IEvent}. This
   * is generally used by an {@link IEventListener} to delegate processing of a
   * specific event. Handlers are not designed to maintain state so do not
   * implement the life-cycle interface.
   * <p>
   * This class and sub-classes are thread safe if the event generic parameter is
   * a system event (system events are bound to a single {@link EventProcessor}).
   * 
   * @author Ramon Servadei
   * 
   * @param <T>
   *            the {@link IEvent} type for this handler.
   * @see MultiEventListener
   */
  public abstract class AbstractEventHandler<T extends IEvent> implements
      IEventListener
  {
      private final static AsyncLog LOG =
          new AsyncLog(AbstractEventHandler.class);
  
      /** The event filter for this instance */
      final Class<? extends IEvent>[] eventFilter;
  
      /**
       * Builds single element arrays with the specified class
       * 
       * @author Ramon Servadei
       */
      private final static class EventFilterBuilder implements
          IObjectBuilder<Class<? extends IEvent>, Class<? extends IEvent>[]>
      {
          @SuppressWarnings("unchecked")
          public Class<? extends IEvent>[] create(Class<? extends IEvent> key)
          {
              Class<? extends IEvent>[] filter = new Class[1];
              filter[0] = key;
              return filter;
          }
      }
  
      /** The store of event filters */
      private final static IAutoCreatingStore<Class<? extends IEvent>, Class<? extends IEvent>[]> eventFilterStore =
          new AutoCreatingStore<Class<? extends IEvent>, Class<? extends IEvent>[]>(
              new EventFilterBuilder());
  
      @SuppressWarnings("unchecked")
      public AbstractEventHandler()
      {
          super();
          // uses reflection to get the type of event
          final ParameterizedType ptype = getParameterizedType(this);
          if (ptype.getActualTypeArguments()[0] instanceof TypeVariable)
          {
              throw new IllegalArgumentException("Must be a parameterised class");
          }
          this.eventFilter =
              eventFilterStore.get((Class<? extends IEvent>) ptype.getActualTypeArguments()[0]);
      }
  
      /**
       * Given a group of {@link AbstractEventHandler} instances, this method
       * returns a map of the handlers indexed by the {@link IEvent} class each
       * one handles. The event for each handler is determined from the generic
      * type argument of the handler implementation.
      * 
      * @param handlers
      *            the handlers to build an {@link IEvent} indexed map of
      * @return a {@link Map} of the handlers, indexed by the {@link IEvent} each
      *         one handles
      */
     @SuppressWarnings("unchecked")
     public static Map<Class<? extends IEvent>, IEventListener> getEventHandlerMappings(
         AbstractEventHandler<? extends IEvent>... handlers)
     {
         Map<Class<? extends IEvent>, IEventListener> listeners =
             CollectionFactory.newMap();
         for (AbstractEventHandler<? extends IEvent> handler : handlers)
         {
             try
             {
                 // use reflection to get the generic event type to map the
                 // handler
                 ParameterizedType ptype = getParameterizedType(handler);
                 if (ptype.getActualTypeArguments()[0] instanceof TypeVariable)
                 {
                     throw new IllegalArgumentException(
                         "Must be a parameterised class");
                 }
                 listeners.put(
                     (Class<? extends IEvent>) ptype.getActualTypeArguments()[0],
                     handler);
             }
             catch (Exception e)
             {
                 logException(null, handler, e);
             }
         }
         if (LOG.isTraceEnabled())
         {
             LOG.trace("Handler map for " + Arrays.toString(handlers) + " is "
                 + CollectionUtils.toFormattedString(listeners));
         }
         return listeners;
     }
 
     /**
      * Walks up the class hierarchy until a parameterised class type is found.
      * 
      * @param handler
      *            the handler to process
      * @return the parameterised type
      * @throws ClassCastException
      *             if the handler does not have a generic type in its hierarchy
      */
     @SuppressWarnings("unchecked")
     private static ParameterizedType getParameterizedType(
         AbstractEventHandler<? extends IEvent> handler)
     {
         Class<? extends AbstractEventHandler> clazz = handler.getClass();
         while (!(clazz.getGenericSuperclass() instanceof ParameterizedType))
         {
             clazz =
                 (Class<? extends AbstractEventHandler>) clazz.getSuperclass();
         }
         return (ParameterizedType) clazz.getGenericSuperclass();
     }
 
     @SuppressWarnings("unchecked")
     public final void update(IEvent event)
     {
         if (getLog().isDebugEnabled())
         {
             getLog().debug("update event=" + event);
         }
         handle((T) event);
     }
 
     public void addedAsListenerFor(IEventSource source)
     {
     }
 
     public void removedAsListenerFrom(IEventSource source)
     {
     }
 
     public final Class<? extends IEvent>[] getEventTypeFilter()
     {
         return this.eventFilter;
     }
 
     /**
      * Handle the event. This will be executed using the context's
      * {@link EventProcessor} instance that is bound to the event's source.
      * 
      * @see IEventManager#queueEvent(IEvent)
      * @param event
      *            the event
      */
     public abstract void handle(T event);
 
     /**
      * Get the log to use
      * 
      * @return the log to use
      */
     protected abstract AsyncLog getLog();
 
 }