/*
      Copyright 2010 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 mirrormap;
  
  import java.io.Serializable;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import mirrormap.collections.IMapListener;
  import mirrormap.commands.AddCommand;
  import mirrormap.commands.ICommand;
  import mirrormap.commands.RemoveCommand;
  import mirrormap.commands.UpdateCommand;
  import mirrormap.nio.IConnectionEndPoint;
  
  /**
   * A listener attached to a {@link MirrorMap} that will send changes in the map
   * to a single {@link IConnectionEndPoint}.
   * 
   * @author Ramon Servadei
   */
  class ConnectionEndPointMapListener implements
      IMapListener<Serializable, Serializable>
  {
      private final static Logger LOGGER =
          Logger.getLogger(ConnectionEndPointMapListener.class.getName());
  
      /** The end point to send changes to */
      private final IConnectionEndPoint connectionEndPoint;
  
      /** The name of the {@link MirrorMap} this listener is attached to */
      private final String mirrorMapName;
  
      /**
       * Construct the listener for a specific {@link MirrorMap} to send changes
       * from the map to the {@link IConnectionEndPoint}
       * 
       * @param connectionEndPoint
       *            the end point to send map changes to
       * @param mirrorMapName
       *            the name of the {@link MirrorMap} this listener is attached to
       */
      ConnectionEndPointMapListener(IConnectionEndPoint connectionEndPoint,
          String mirrorMapName)
      {
          super();
          this.connectionEndPoint = connectionEndPoint;
          this.mirrorMapName = mirrorMapName;
      }
  
      public void didAdd(Serializable key, Serializable value)
      {
          if (isRemoteChange())
          {
              return;
          }
          final ICommand command = new AddCommand(this.mirrorMapName, key, value);
          send(command);
      }
  
      public void didRemove(Serializable key, Serializable value)
      {
          if (isRemoteChange())
          {
              return;
          }
          final ICommand command = new RemoveCommand(this.mirrorMapName, key);
          send(command);
      }
  
      public void didUpdate(Serializable key, Serializable oldValue,
          Serializable newValue)
      {
          if (isRemoteChange())
          {
              return;
          }
          final ICommand command =
              new UpdateCommand(this.mirrorMapName, key, newValue);
          send(command);
      }
  
      public void willAdd(Serializable key, Serializable value)
      {
          // noop
      }
 
     public void willRemove(Serializable key)
     {
         // noop
     }
 
     public void willUpdate(Serializable key, Serializable currentValue,
         Serializable newValue)
     {
         // noop
     }
 
     @Override
     public int hashCode()
     {
         final int prime = 31;
         int result = 1;
         result =
             prime
                 * result
                 + ((connectionEndPoint == null) ? 0
                     : connectionEndPoint.hashCode());
         result =
             prime * result
                 + ((mirrorMapName == null) ? 0 : mirrorMapName.hashCode());
         return result;
     }
 
     @Override
     public boolean equals(Object obj)
     {
         if (this == obj)
             return true;
         if (obj == null)
             return false;
         if (getClass() != obj.getClass())
             return false;
         ConnectionEndPointMapListener other =
             (ConnectionEndPointMapListener) obj;
         if (mirrorMapName == null)
         {
             if (other.mirrorMapName != null)
                 return false;
         }
         else
             if (!mirrorMapName.equals(other.mirrorMapName))
                 return false;
         if (connectionEndPoint == null)
         {
             if (other.connectionEndPoint != null)
                 return false;
         }
         else
             if (!connectionEndPoint.equals(other.connectionEndPoint))
                 return false;
         return true;
     }
 
     private void send(final ICommand command)
     {
         if (LOGGER.isLoggable(Level.FINEST))
         {
             LOGGER.finest("Sending " + command.toString() + " to "
                 + this.connectionEndPoint);
         }
         if (this.connectionEndPoint.isActive())
         {
             this.connectionEndPoint.send(command.getBytes());
         }
         else
         {
             if (LOGGER.isLoggable(Level.INFO))
             {
                 LOGGER.info(this.connectionEndPoint
                     + " is inactive, unregistering from mirror map "
                     + this.mirrorMapName);
             }
             MirrorMap.get(this.mirrorMapName).removeListener(this);
         }
     }
 
     /**
      * Checks if the thread is the MirrorMap I/O thread
      * 
      * @return <code>true</code> if the current thread is the MirrorMap I/O
      *         thread
      */
     private final boolean isRemoteChange()
     {
         return Thread.currentThread().getName().equals(
             MirrorMap.getClientThreadName());
     }
 
 }