/*
    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.COLON;
  import static fulmine.util.Utils.nullCheck;
  
  import java.util.Arrays;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  
  import fulmine.AbstractLifeCycle;
  import fulmine.event.IEvent;
  import fulmine.event.IEventManager;
  import fulmine.event.IEventSource;
  import fulmine.event.system.AbstractSystemEvent;
  import fulmine.event.system.ISystemEvent;
  import fulmine.util.collection.CollectionFactory;
  import fulmine.util.log.AsyncLog;
  
  /**
   * An event listener that is a composition of multiple internal
   * {@link IEventListener} objects that each handle a specific type of
   * {@link IEvent}. Events received by this listener are passed on to the
   * listener that is mapped to the event's class.
   * <p>
   * This class registers itself with event sources and then passes the events to
   * the appropriate mapped event listener. The internal listeners are never
   * registered directly with the event sources.
   * <p>
   * This needs to locate the listener per event by checking <i>assignment
   * compatibility</i> of the event with all listeners' registered event class.
   * This could mean that multiple internal listeners receive the event if there
   * is an intersection between the registered event class of the listeners and
   * the current event's class.
   * <p>
   * During the {@link #start()} and {@link #destroy()} methods, only listeners
   * that are mapped to an {@link AbstractSystemEvent} event will cause the
   * multi-event listener to be registered/unregistered against the event's
   * 'singleton' source ({@link IEventManager#getSystemEventSource(Class)}).
   * 
   * @author Ramon Servadei
   */
  public class MultiEventListener extends AbstractLifeCycle implements
      ILifeCycleEventListener
  {
      private final static AsyncLog LOG = new AsyncLog(MultiEventListener.class);
  
      /** The listener for each event type */
      final Map<Class<? extends IEvent>, IEventListener> listeners;
  
      /** The name for this */
      private String name;
  
      /** Events context */
      private final IEventManager context;
  
      /**
       * The filter for events handled by this. The filter is a composition of all
       * the event filters of the composite {@link IEventListener} instances.
       */
      private final Class<? extends IEvent>[] filter;
  
      /**
       * Standard constructor
       * 
       * @param name
       *            the name for this
       * @param context
       *            the event context to use
       * @param listeners
       *            maps the {@link IEvent} type to the {@link IEventListener}
       *            object that will process events of that type
       */
      @SuppressWarnings("unchecked")
      public MultiEventListener(String name, IEventManager context,
          Map<Class<? extends IEvent>, IEventListener> listeners)
      {
          super();
          nullCheck(name, "Null name");
          nullCheck(listeners, "No listeners provided");
          this.context = context;
          this.name = name;
          this.listeners = listeners;
          List<Class<? extends IEvent>> filterList = CollectionFactory.newList();
         for (IEventListener listener : listeners.values())
         {
             filterList.addAll(Arrays.asList(listener.getEventTypeFilter()));
         }
         this.filter = filterList.toArray(new Class[filterList.size()]);
     }
 
     @SuppressWarnings("unchecked")
     @Override
     protected void doDestroy()
     {
         final Set<Class<? extends IEvent>> eventTypes = getListeners().keySet();
         for (Class<? extends IEvent> eventType : eventTypes)
         {
             if (AbstractSystemEvent.class.isAssignableFrom(eventType))
             {
                 getContext().getSystemEventSource(
                     (Class<? extends ISystemEvent>) eventType).removeListener(
                     this);
             }
         }
         getListeners().clear();
     }
 
     @Override
     protected AsyncLog getLog()
     {
         return LOG;
     }
 
     @SuppressWarnings("unchecked")
     @Override
     protected void doStart()
     {
         final Set<Class<? extends IEvent>> eventTypes = getListeners().keySet();
         for (Class<? extends IEvent> eventType : eventTypes)
         {
             if (AbstractSystemEvent.class.isAssignableFrom(eventType))
             {
                 getContext().getSystemEventSource(
                     (Class<? extends ISystemEvent>) eventType).addListener(this);
             }
         }
     }
 
     public final void update(IEvent event)
     {
         if (getLog().isTraceEnabled())
         {
             getLog().trace("update event=" + event);
         }
         for (int i = 0; i < getEventTypeFilter().length; i++)
         {
             Class<? extends IEvent> eventType = getEventTypeFilter()[i];
             if (eventType.isInstance(event))
             {
                 final IEventListener eventListener =
                     getListeners().get(eventType);
                 if (eventListener != null)
                 {
                     eventListener.update(event);
                 }
             }
         }
     }
 
     public void addedAsListenerFor(IEventSource source)
     {
         // noop
     }
 
     public void removedAsListenerFrom(IEventSource source)
     {
         // noop
     }
 
     public Class<? extends IEvent>[] getEventTypeFilter()
     {
         return this.filter;
     }
 
     Map<Class<? extends IEvent>, IEventListener> getListeners()
     {
         return this.listeners;
     }
 
     String getName()
     {
         return this.name;
     }
 
     IEventManager getContext()
     {
         return this.context;
     }
 
     @Override
     public final String toString()
     {
         return getClass().getSimpleName() + COLON + name;
     }
 }