/*
      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.rpc;
  
  import static fulmine.util.Utils.string;
  import fulmine.model.container.IContainer;
  import fulmine.model.field.BooleanField;
  import fulmine.model.field.FieldUtils;
  import fulmine.model.field.IField;
  import fulmine.model.field.IntegerField;
  import fulmine.model.field.StringField;
  import fulmine.util.reference.is;
  
  /**
   * Standard implementation.
   * 
   * @author Ramon Servadei
   */
  public final class RpcResult implements IRpcResult
  {
  
      /** The marker for the RPC call this result is for. */
      private IRpcMarker marker;
  
      /** The exception message from the RPC */
      private final String exceptionMessage;
  
      /** The result */
      private final IField result;
  
      /** Whether the RPC executed successfully */
      private final boolean successful;
  
      /**
       * Construct the RPC result from a result record. This constructor is called
       * in the remote context that called the RPC.
       * 
       * @param definition
       *            the definition for the RPC
       * @param resultRecord
       *            the result record
       */
      public RpcResult(IRpcDefinition definition, IContainer resultRecord)
      {
          if (!resultRecord.contains(MARKER))
          {
              throw new IllegalArgumentException(
                  "No RPC result marker in result record " + resultRecord + " "
                      + definition);
          }
          if (!resultRecord.contains(IS_SUCCESSFUL))
          {
              throw new IllegalArgumentException(
                  "No success flag in result record " + resultRecord + " "
                      + definition);
          }
          this.marker = new RpcMarker(resultRecord.getIntegerField(MARKER).get());
          this.successful = resultRecord.getBooleanField(IS_SUCCESSFUL).get();
          if (resultRecord.contains(EXCEPTION))
          {
              this.exceptionMessage =
                  resultRecord.getStringField(EXCEPTION).get();
          }
          else
          {
              this.exceptionMessage = null;
          }
          if (resultRecord.contains(RESULT))
          {
              try
              {
                  // construct the result field
                  this.result =
                      FieldUtils.createFromString(definition.getResultType(),
                          RESULT, resultRecord.getStringField(RESULT).get());
              }
              catch (Exception e)
              {
                  throw new IllegalArgumentException(
                      "Could not get result value from result record "
                          + resultRecord + " " + definition, e);
              }
          }
          else
          {
              this.result = null;
         }
     }
 
     /**
      * Construct the RPC result.
      * 
      * @param successful
      *            whether the RPC executed successfully
      * @param result
      *            the result
      * @param exceptionMessage
      *            the exception, if any
      */
     public RpcResult(boolean successful, IField result, String exceptionMessage)
     {
         super();
         this.successful = successful;
         this.result = result;
         this.exceptionMessage = exceptionMessage;
     }
 
     public String getExceptionMessage()
     {
         return this.exceptionMessage;
     }
 
     public IField getResult()
     {
         return this.result;
     }
 
     public boolean isSuccessful()
     {
         return this.successful;
     }
 
     public IRpcMarker getMarker()
     {
         return this.marker;
     }
 
     public void updateResultRecord(IRpcMarker marker, IContainer resultRecord)
     {
         if (!resultRecord.contains(MARKER))
         {
             resultRecord.add(new IntegerField(MARKER));
         }
         resultRecord.getIntegerField(MARKER).set(marker.getId());
 
         if (!resultRecord.contains(IS_SUCCESSFUL))
         {
             resultRecord.add(new BooleanField(IS_SUCCESSFUL));
         }
         resultRecord.getBooleanField(IS_SUCCESSFUL).set(isSuccessful());
 
         if (!resultRecord.contains(EXCEPTION))
         {
             resultRecord.add(new StringField(EXCEPTION));
         }
         resultRecord.getStringField(EXCEPTION).set(getExceptionMessage());
 
         // we send the result as its string value, not great but it'll do
         if (!resultRecord.contains(RESULT))
         {
             resultRecord.add(new StringField(RESULT));
         }
         final IField rpcResult = getResult();
         resultRecord.getStringField(RESULT).set(
             rpcResult == null ? null : rpcResult.getValueAsString());
     }
 
     @Override
     public String toString()
     {
         return string(this, "marker=" + getMarker() + ", success="
             + isSuccessful() + ", result=" + getResult() + ", exception="
             + getExceptionMessage());
     }
 
     @Override
     public int hashCode()
     {
         final int prime = 31;
         int result = 1;
         result =
             prime
                 * result
                 + ((exceptionMessage == null) ? 0 : exceptionMessage.hashCode());
         result = prime * result + ((marker == null) ? 0 : marker.hashCode());
         result =
             prime * result
                 + ((this.result == null) ? 0 : this.result.hashCode());
         result = prime * result + (successful ? 1231 : 1237);
         return result;
     }
 
     @Override
     public boolean equals(Object obj)
     {
         if (is.same(this, obj))
         {
             return true;
         }
         if (is.differentClass(this, obj))
         {
             return false;
         }
         RpcResult other = (RpcResult) obj;
         return is.eq(getMarker(), other.getMarker())
             && is.eq(getExceptionMessage(), other.getExceptionMessage())
             && is.eq(getResult(), other.getResult())
             && is.eq(isSuccessful(), other.isSuccessful());
     }
 }