/*
      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.ByteArrayInputStream;
  import java.io.ObjectInputStream;
  import java.io.Serializable;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.Map.Entry;
  import java.util.logging.Level;
  import java.util.logging.Logger;
  
  import mirrormap.commands.AbstractCommand;
  import mirrormap.commands.ICommand;
  import mirrormap.commands.PeerConnectedCommand;
  import mirrormap.commands.PeerDisconnectedCommand;
  import mirrormap.commands.RegisterCommand;
  import mirrormap.commands.UnregisterCommand;
  import mirrormap.nio.IConnectionEndPoint;
  import mirrormap.nio.IConnectionEndPointReceiver;
  
  /**
   * The end point receiver on the server-side that handles the serialised
   * {@link ICommand} objects sent from a remote client-side end point.
   * <p>
   * Each {@link RegisterCommand} that is processed has a new
   * {@link ConnectionEndPointMapListener} created and attached to the
   * corresponding {@link MirrorMap}. Changes in the map will be notified to the
   * listener that will broadcast the change back to the client via the
   * {@link IConnectionEndPoint} of this receiver.
   * 
   * @author Ramon Servadei
   */
  class ServerCommandReceiver implements IConnectionEndPointReceiver
  {
      /**
       * Implementation that returns ServerCommandReceiver instances
       * 
       * @author Ramon Servadei
       */
      static final class ServerCommandReceiverFactory implements IFactory
      {
          public IConnectionEndPointReceiver createEndPointRecevier()
          {
              return new ServerCommandReceiver();
          }
      }
  
      private final static Logger LOGGER =
          Logger.getLogger(ServerCommandReceiver.class.getName());
  
      /**
       * Tracks all the connection end points to this server instance.
       */
      private final static List<IConnectionEndPoint> allEndPoints =
          new ArrayList<IConnectionEndPoint>();
  
      /** The connection end point this receiver is associated with */
      protected IConnectionEndPoint connectionEndPoint;
  
      /**
       * The listeners per named {@link MirrorMap} that the client-side end point
       * has requested a registration for. Synchronized.
       */
      protected final Map<String, ConnectionEndPointMapListener> listeners =
          Collections.synchronizedMap(new HashMap<String, ConnectionEndPointMapListener>());
  
      ServerCommandReceiver()
      {
          super();
      }
  
      public final void receive(byte[] data)
      {
          ObjectInputStream ois;
          try
          {
              ois = new ObjectInputStream(new ByteArrayInputStream(data));
              Object received = ois.readObject();
             if (received instanceof ICommand)
             {
                 doReceive((ICommand) received);
             }
             else
             {
                 if (LOGGER.isLoggable(Level.INFO))
                 {
                     LOGGER.info("Unhandled object " + received);
                 }
             }
         }
         catch (Exception e)
         {
             Utils.logException(LOGGER, "Could not handle received data from "
                 + Utils.safeToString(this.connectionEndPoint), e);
         }
     }
 
     /**
      * Execute the actual logic to handle received {@link ICommand}
      * 
      * @param command
      *            the command received
      */
     protected void doReceive(ICommand command)
     {
         if (LOGGER.isLoggable(Level.FINEST))
         {
             LOGGER.finest(command.toString());
         }
         if (command instanceof RegisterCommand)
         {
             final String mirrorMapName = command.getMirrorMapName();
             MirrorMap<Serializable, Serializable> target =
                 MirrorMap.create(mirrorMapName,
                     new HashMap<Serializable, Serializable>());
             final ConnectionEndPointMapListener listener =
                 new ConnectionEndPointMapListener(this.connectionEndPoint,
                     mirrorMapName);
             if (target.addListener(listener))
             {
                 this.listeners.put(mirrorMapName, listener);
             }
             sendCommandToAll(new PeerConnectedCommand(mirrorMapName));
         }
         else
         {
             if (command instanceof UnregisterCommand)
             {
                 final String mirrorMapName = command.getMirrorMapName();
                 final ConnectionEndPointMapListener listener =
                     this.listeners.remove(mirrorMapName);
                 if (listener != null)
                 {
                     MirrorMap<Serializable, Serializable> target =
                         MirrorMap.get(mirrorMapName);
                     if (target != null)
                     {
                         target.removeListener(listener);
                     }
                 }
                 sendCommandToAll(new PeerDisconnectedCommand(mirrorMapName));
             }
             else
             {
                 executeCommand(command);
             }
         }
     }
 
     /**
      * Helper method to send the command to all end points known to this VM's
      * server
      * 
      * @param command
      *            the command to send
      */
     private void sendCommandToAll(AbstractCommand command)
     {
         synchronized (allEndPoints)
         {
             for (Iterator<IConnectionEndPoint> iterator =
                 allEndPoints.iterator(); iterator.hasNext();)
             {
                 IConnectionEndPoint endPoint = iterator.next();
                 if (!endPoint.isActive())
                 {
                     iterator.remove();
                 }
                 else
                 {
                     endPoint.send(command.getBytes());
                 }
             }
         }
     }
 
     /**
      * Executes the commend and also informs the
      * {@link ConnectionEndPointMapListener} to ignore sending out this change
      * so we don't end up with infinite looping notifications.
      * 
      * @param command
      *            the command
      */
     protected void executeCommand(ICommand command)
     {
         final String mirrorMapName = command.getMirrorMapName();
         final ConnectionEndPointMapListener listener =
             this.listeners.get(mirrorMapName);
         if (listener != null)
         {
             command.execute();
         }
     }
 
     public void setEndPointConnection(IConnectionEndPoint connectionEndPoint)
     {
         this.connectionEndPoint = connectionEndPoint;
         synchronized (allEndPoints)
         {
             allEndPoints.add(this.connectionEndPoint);
         }
     }
 
     public void destroy()
     {
         synchronized (this.listeners)
         {
             // iterate over a copy
             final Set<Entry<String, ConnectionEndPointMapListener>> entrySet =
                 new HashSet<Entry<String, ConnectionEndPointMapListener>>(
                     this.listeners.entrySet());
             for (Entry<String, ConnectionEndPointMapListener> entry : entrySet)
             {
                 destroyListener(entry);
             }
         }
         synchronized (allEndPoints)
         {
             allEndPoints.remove(this.connectionEndPoint);
         }
         this.connectionEndPoint = null;
     }
 
     /**
      * Destroy the {@link ConnectionEndPointMapListener} in the entry
      */
     protected void destroyListener(
         Entry<String, ConnectionEndPointMapListener> entry)
     {
         MirrorMap.get(entry.getKey()).removeListener(entry.getValue());
     }
 }