/*
      Copyright 2009 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.distribution;
  
  import org.apache.commons.logging.Log;
  
  import fulmine.context.IFulmineContext;
  import fulmine.context.IRemoteUpdateHandler;
  import fulmine.model.field.IntegerField;
  import fulmine.model.field.StringField;
  import fulmine.rpc.IRpcDefinition;
  import fulmine.rpc.IRpcResult;
  import fulmine.util.Utils;
  import fulmine.util.log.AsyncLog;
  import fulmine.util.reference.Values;
  import fulmine.util.reference.is;
  
  /**
   * A standard implementation.
   * 
   * @author Ramon Servadei
   */
  public final class RemoteUpdateInvoker implements IRemoteUpdateInvoker
  {
      private final static Log LOG = new AsyncLog(RemoteUpdateInvoker.class);
  
      /**
       * System property to define the timeout (in milliseconds) for waiting for
       * RPC invocations.
       * 
       * @see #DEFAUL_RPC_TIMEOUT
       */
      public final static String RPC_TIMEOUT_PROPERTY =
          RemoteUpdateInvoker.class.getSimpleName() + ".rpcTimeout";
  
      /** The default RPC timeout, 5 seconds */
      public final static String DEFAUL_RPC_TIMEOUT = "5000";
  
      /** RPC timeout */
      private final static int TIMEOUT =
          Integer.parseInt(System.getProperty(RPC_TIMEOUT_PROPERTY,
              DEFAUL_RPC_TIMEOUT));
  
      /** Signals if the 'update remote container' RPC is available */
      boolean available;
  
      /** The identity of the remote context this works for */
      final String remoteContextIdentity;
  
      /** The context */
      final IFulmineContext context;
  
      /**
       * Standard constructor
       * 
       * @param remoteContextIdentity
       *            the remote context identity this invoker handles.
       */
      public RemoteUpdateInvoker(String remoteContextIdentity,
          IFulmineContext context)
      {
          super();
          this.remoteContextIdentity = remoteContextIdentity;
          this.context = context;
      }
  
      public void procedureAvailable(String remoteContextIdentity,
          IRpcDefinition rpcDefinition)
      {
          if (IRemoteUpdateHandler.RPC_NAME.equals(rpcDefinition.getName()))
          {
              // we have found it, schedule any pending invocations to be executed
              if (LOG.isDebugEnabled())
              {
                  LOG.debug("Found 'update remote container' RPC for "
                      + remoteContextIdentity);
              }
              synchronized (this)
              {
                  this.available = true;
                  this.notifyAll();
              }
          }
      }
  
      public void procedureUnavailable(String remoteContextIdentity,
         IRpcDefinition rpcDefinition)
     {
         if (IRemoteUpdateHandler.RPC_NAME.equals(rpcDefinition.getName()))
         {
             if (LOG.isDebugEnabled())
             {
                 LOG.debug("Lost 'update remote container' RPC for "
                     + remoteContextIdentity);
             }
             synchronized (this)
             {
                 this.available = false;
             }
         }
     }
 
     public IRpcResult invoke(String remoteContextIdentity,
         StringField identity, IntegerField type, IntegerField domain,
         StringField fieldName, StringField valueAsString,
         IntegerField permissionApp, IntegerField permissionCode,
         StringField originatingRemoteContextIdentity)
     {
         if (LOG.isDebugEnabled())
         {
             LOG.debug("Invoking update remote container RPC with args "
                 + new Values(remoteContextIdentity,
                     IRemoteUpdateHandler.RPC_NAME, identity, type, domain,
                     fieldName, valueAsString, permissionApp, permissionCode,
                     originatingRemoteContextIdentity));
         }
         synchronized (this)
         {
             while (!this.available)
             {
                 if (LOG.isDebugEnabled())
                 {
                     LOG.debug("RPC to update remote container is not available, waiting until it is...");
                 }
                 try
                 {
                     this.wait(TIMEOUT);
                 }
                 catch (InterruptedException e)
                 {
                     Utils.logException(LOG, this, e);
                 }
             }
         }
         return this.context.invoke(remoteContextIdentity,
             IRemoteUpdateHandler.RPC_NAME, identity, type, domain, fieldName,
             valueAsString, permissionApp, permissionCode,
             originatingRemoteContextIdentity);
     }
 
     @Override
     public int hashCode()
     {
         final int prime = 31;
         int result = 1;
         result =
             prime
                 * result
                 + ((this.remoteContextIdentity == null) ? 0
                     : this.remoteContextIdentity.hashCode());
         return result;
     }
 
     @Override
     public boolean equals(Object obj)
     {
         if (is.same(this, obj))
         {
             return true;
         }
         if (is.differentClass(this, obj))
         {
             return false;
         }
         RemoteUpdateInvoker other = (RemoteUpdateInvoker) obj;
         return is.eq(this.remoteContextIdentity, other.remoteContextIdentity);
     }
 
 }