/*
      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.subscription;
  
  import static fulmine.util.Utils.logException;
  import static fulmine.util.Utils.nullCheck;
  import static fulmine.util.Utils.string;
  
  import java.util.Collection;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.commons.logging.Log;
  
  import fulmine.IAddressable;
  import fulmine.IDomain;
  import fulmine.IType;
  import fulmine.event.IEventSource;
  import fulmine.event.listener.IEventListener;
  import fulmine.util.collection.CollectionFactory;
  import fulmine.util.log.AsyncLog;
  
  /**
   * The base implementation of a subscription.
   * <p>
   * Thread safe.
   * 
   * @author Ramon Servadei
   */
  public class Subscription implements ISubscription
  {
      private final static AsyncLog LOG = new AsyncLog(Subscription.class);
  
      /** The source instances this subscription has matched */
      final Collection<IEventSource> matches;
  
      /**
       * The listeners used by the subscription to register against matching event
       * sources
       */
      final List<IEventListener> listeners;
  
      /** The parameters for the subscription */
      private final ISubscriptionParameters parameters;
  
      /**
       * Construct the subscription to match the subscription passed in.
       * 
       * @param subscription
       *            the subscription subscription for this
       */
      protected Subscription(ISubscriptionParameters parameters)
      {
          super();
          nullCheck(parameters, "no subscription parameter provided");
          this.parameters = parameters;
          this.listeners = CollectionFactory.newList(1);
          this.matches = CollectionFactory.newList(1);
      }
  
      public synchronized final boolean addMatch(IEventSource source)
      {
          if (!this.matches.contains(source))
          {
              if (getLog().isTraceEnabled())
              {
                  getLog().trace(
                      "Adding match " + source.toIdentityString() + " to " + this);
              }
              this.matches.add(source);
              if (source.isActive())
              {
                  for (IEventListener eventListener : this.listeners)
                  {
                      try
                      {
                          source.addListener(eventListener);
                      }
                      catch (Exception e)
                      {
                          logException(getLog(), source, e);
                      }
                  }
                  doAddOperation(source);
                  return true;
              }
             logException(getLog(), this + " is attempting to subscribe"
                 + " to inactive event source: " + source, new Exception());
         }
         return false;
     }
 
     public synchronized final boolean removeMatch(
         ISubscriptionParameters parameters)
     {
         if (parameters == null)
         {
             return false;
         }
         for (Iterator<? extends IEventSource> iterator =
             this.matches.iterator(); iterator.hasNext();)
         {
             final IEventSource source = iterator.next();
             try
             {
                 if (parameters.includes(source))
                 {
                     if (getLog().isTraceEnabled())
                     {
                         getLog().trace(
                             "Removing identity=" + source.getIdentity()
                                 + ", type=" + source.getType() + ", domain="
                                 + source.getDomain() + " from " + this);
                     }
                     iterator.remove();
                     // remove the listeners of this subscription from the source
                     for (IEventListener eventListener : this.listeners)
                     {
                         try
                         {
                             source.removeListener(eventListener);
                         }
                         catch (Exception e)
                         {
                             logException(LOG, source, e);
                         }
                     }
                     doRemoveOperation(source);
                     return true;
                 }
             }
             catch (Exception e)
             {
                 logException(LOG, source, e);
             }
         }
         return false;
     }
 
     public synchronized final Collection<IEventSource> getMatches()
     {
         return CollectionFactory.newList(this.matches);
     }
 
     public synchronized final List<IEventListener> getListeners()
     {
         return CollectionFactory.newList(this.listeners);
     }
 
     public synchronized final boolean addListener(IEventListener listener)
     {
         return doAddListener(listener);
     }
 
     public synchronized final boolean removeListener(IEventListener listener)
     {
         if (this.listeners.contains(listener))
         {
             this.listeners.remove(listener);
             // remove the listener to currently matched sources
             for (IEventSource source : this.matches)
             {
                 try
                 {
                     source.removeListener(listener);
                 }
                 catch (Exception e)
                 {
                     logException(getLog(), source, e);
                 }
             }
             if (getLog().isInfoEnabled())
             {
                 getLog().info("Removed listener " + listener + " from " + this);
             }
             return true;
         }
         return false;
     }
 
     public final IDomain getDomain()
     {
         return this.parameters.getDomain();
     }
 
     public final String getIdentity()
     {
         return this.parameters.getIdentity();
     }
 
     public final IType getType()
     {
         return this.parameters.getType();
     }
 
     public final String getAddress()
     {
         return this.parameters.getAddress();
     }
 
     public final boolean includes(IAddressable parameters)
     {
         return this.parameters.includes(parameters);
     }
 
     public synchronized void destroy()
     {
         if (getLog().isTraceEnabled())
         {
             getLog().trace("Destroying " + this);
         }
         // do not destroy the listener!
         for (IEventSource source : this.matches)
         {
             try
             {
                 for (IEventListener listener : this.listeners)
                 {
                     try
                     {
                         source.removeListener(listener);
                     }
                     catch (Exception e)
                     {
                         logException(LOG, source, e);
                     }
                 }
                 doRemoveOperation(source);
             }
             catch (Exception e)
             {
                 logException(LOG, source, e);
             }
         }
         this.matches.clear();
         this.listeners.clear();
     }
 
     /**
      * Template method for the operation to perform when a source match is
      * added.
      * 
      * @param source
      *            the source the operation applies to
      * @return <code>true</code> if the operation did something
      */
     protected boolean doAddOperation(IEventSource source)
     {
         return true;
     }
 
     /**
      * Template method for the operation to perform when a source match is
      * removed.
      * 
      * @param source
      *            the source the operation applies to
      * @return <code>true</code> if the operation did something
      */
     protected boolean doRemoveOperation(IEventSource source)
     {
         return true;
     }
 
     private boolean doAddListener(IEventListener listener)
     {
         if (!this.listeners.contains(listener))
         {
             this.listeners.add(listener);
             if (getLog().isTraceEnabled())
             {
                 getLog().trace("[adding listener] " + listener + " to " + this);
             }
             // add the listener to currently matched sources
             for (IEventSource source : this.matches)
             {
                 try
                 {
                     source.addListener(listener);
                 }
                 catch (Exception e)
                 {
                     logException(getLog(), source, e);
                 }
             }
             if (getLog().isInfoEnabled())
             {
                 getLog().info("Added listener " + listener + " to " + this);
             }
             return true;
         }
         if (getLog().isTraceEnabled())
         {
             getLog().trace(this + " already contains listener " + listener);
         }
         return false;
     }
 
     protected Log getLog()
     {
         return LOG;
     }
 
     @Override
     public synchronized final String toString()
     {
         return string(this, this.parameters + ", matches="
             + this.matches.size());
     }
 
     @Override
     public final int hashCode()
     {
         return ((parameters == null) ? 0 : parameters.hashCode());
     }
 
     @Override
     public final boolean equals(Object obj)
     {
         if (this == obj)
         {
             return true;
         }
         if (obj == null)
         {
             return false;
         }
         if (!(obj instanceof ISubscriptionParameters))
         {
             return false;
         }
         final ISubscriptionParameters other = (ISubscriptionParameters) obj;
         if (this.parameters == null)
         {
             return false;
         }
         return this.parameters.equals(other);
     }
 }