/*
      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.model.container.subscription;
  
  import static fulmine.util.Utils.logException;
  
  import java.util.Collection;
  import java.util.Map;
  
  import fulmine.IAddressable;
  import fulmine.context.IFrameworkContext;
  import fulmine.event.IEventSource;
  import fulmine.event.ImageEvent;
  import fulmine.event.listener.AbstractEventHandler;
  import fulmine.event.listener.IEventListener;
  import fulmine.event.listener.ILifeCycleEventListener;
  import fulmine.event.listener.MultiSystemEventListener;
  import fulmine.event.subscription.ISubscription;
  import fulmine.event.subscription.ISubscriptionFactory;
  import fulmine.event.subscription.ISubscriptionManager;
  import fulmine.event.subscription.ISubscriptionParameters;
  import fulmine.event.subscription.SubscriptionManager;
  import fulmine.event.system.ISystemEventListener;
  import fulmine.model.container.IContainer;
  import fulmine.model.container.events.ContainerCreatedEvent;
  import fulmine.model.container.events.ContainerDestroyedEvent;
  import fulmine.protocol.specification.FrameReader;
  import fulmine.util.log.AsyncLog;
  
  /**
   * Standard implementation of an {@link ISubscriptionManager} for
   * {@link IContainer} subscriptions. This is thread safe.
   * <p>
   * Registers for the following system events:
   * <ul>
   * <li>{@link ContainerCreatedEvent}
   * <li>{@link ContainerDestroyedEvent}
   * </ul>
   * 
   * @see ContainerSubscription
   * @author Ramon Servadei
   */
  public class ContainerSubscriptionManager extends SubscriptionManager
  {
      /**
       * Handles {@link ContainerCreatedEvent} events
       * 
       * @author Ramon Servadei
       */
      private class ContainerCreatedEventHandler extends
          AbstractEventHandler<ContainerCreatedEvent> implements
          ISystemEventListener
      {
          @Override
          public AsyncLog getLog()
          {
              return LOG;
          }
  
          @Override
          public void handle(ContainerCreatedEvent event)
          {
              eventSourceCreated(event);
          }
      }
  
      /**
       * Handles {@link ContainerDestroyedEvent} events
       * 
       * @author Ramon Servadei
       */
      private class ContainerDestroyedEventHandler extends
          AbstractEventHandler<ContainerDestroyedEvent> implements
          ISystemEventListener
      {
          @Override
          public AsyncLog getLog()
          {
              return LOG;
          }
  
          @Override
          public void handle(ContainerDestroyedEvent event)
          {
              eventSourceDestroyed(event);
          }
     }
 
     private final static AsyncLog LOG =
         new AsyncLog(ContainerSubscriptionManager.class);
 
     protected ILifeCycleEventListener eventHandler;
 
     /**
      * Standard constructor
      * 
      * @param context
      *            the context this manager is associated with
      */
     public ContainerSubscriptionManager(IFrameworkContext context)
     {
         this(context, null);
     }
 
     /**
      * Standard constructor
      * 
      * @param context
      *            the context this manager is associated with
      * @param factory
      *            the container subscription factory to use
      */
     @SuppressWarnings("unchecked")
     public ContainerSubscriptionManager(IFrameworkContext context,
         ISubscriptionFactory factory)
     {
         super(context, (factory == null ? new ContainerSubscriptionFactory()
             : factory));
         this.eventHandler =
             new MultiSystemEventListener(this.getClass().getSimpleName(),
                 context, AbstractEventHandler.getEventHandlerMappings(
                     new ContainerCreatedEventHandler(),
                     new ContainerDestroyedEventHandler()));
     }
 
     @Override
     protected final void doEventSourceCreated(IAddressable identity)
     {
         // trigger an image to be generated for the newly created container...
         final IContainer container = (IContainer) identity;
         container.addEvent(new ImageEvent());
         if (!container.isFrameActive())
         {
             container.flushFrame();
         }
     }
 
     @Override
     protected void doAddListener(ISubscriptionParameters parameters,
         IEventListener listener)
     {
         final Collection<IEventSource> matches =
             getSubscribedSources(parameters);
         if (matches.size() > 0)
         {
             /*
              * This is not pretty - we need to masquerade as being in a
              * FrameReader context to ensure we can bypass the usual checks that
              * prevent remote containers flushed - this happens when a duplicate
              * subscription for a remote container occurs and we just want to
              * flush the available remote one to re-trigger notifications.
              */
             try
             {
                 FrameReader.inContext.set(Boolean.TRUE);
                 for (IEventSource source : matches)
                 {
                     try
                     {
                         IContainer container = (IContainer) source;
                         /*
                          * On adding, we need to trigger an image for an update,
                          * this affects all listeners unfortunately. If we don't
                          * do this and try to provide the image to the new
                          * listener in this thread, we break some assumptions
                          * about a source only being serviced by a fixed, single
                          * thread.
                          */
                         container.addEvent(new ImageEvent());
                         if (!container.isFrameActive())
                         {
                             container.flushFrame();
                         }
                     }
                     catch (Exception e)
                     {
                         logException(getLog(), source, e);
                     }
                 }
             }
             finally
             {
                 FrameReader.inContext.remove();
             }
         }
     }
 
     /**
      * Template method to get the {@link IEventSource} identified by the
      * {@link IAddressable} argument.
      * 
      * @param id
      *            identifies the event source
      * @return the {@link IEventSource} implementation to use
      */
     @Override
     protected IEventSource doGetEventSource(IAddressable id)
     {
         return getContext().getLocalContainer(id.getIdentity(), id.getType(),
             id.getDomain());
     }
 
     /**
      * Template method to identify if the {@link IEventSource} identified by the
      * {@link IAddressable} argument exists.
      * 
      * @param id
      *            identifies the event source
      * 
      * @return <code>true</code> if the container exists in the current context
      *         scope
      */
     @Override
     protected boolean doEventSourceExists(IAddressable id)
     {
         return getContext().containsLocalContainer(id.getIdentity(),
             id.getType(), id.getDomain());
     }
 
     @Override
     protected final void doStart()
     {
         this.eventHandler.start();
     }
 
     @Override
     protected void doDestroy()
     {
         super.doDestroy();
         this.eventHandler.destroy();
     }
 
     @Override
     protected AsyncLog getLog()
     {
         return LOG;
     }
 
     @Override
     protected Collection<? extends IEventSource> doGetEventSources()
     {
         return getContext().getLocalContainers();
     }
 
     /**
      * Nasty package scoped access to the underlying subscriptions. Needed for
      * unit tests to setup state. <b>Do not use this in application code, there
      * are thread safety issues.</b>
      * 
      * @return as per {@link #getSubscriptions()}
      */
     final Map<ISubscriptionParameters, ISubscription> _getSubscriptions()
     {
         return getSubscriptions();
     }
 }