// Copyright (c) 2003, Chad Woolley, All rights reserved.
   
   package org.virtualmock.call;
   
   import org.virtualmock.VM;
   import org.virtualmock.matcher.ArgMatcher;
   
   
   /***
   * Represents a method invocation of a recorded mock call.  This is a subclass
   * of Call which only contains information which is specific to recorded
   * calls.
   *
   * @author Chad Woolley
   * @version $Revision: 1.32 $
   */
  public class RecordedCall extends Call {
      private ArgMatcher[] argMatchers = null;
  
      /*** Flag to indicate if this call can have unlimited invocations. */
      private boolean unlimitedInvocations = false;
  
      /*** The number of times this recorded call has been invoked. */
      private int invocationCount = 0;
  
      /***
       * Creates a new RecordedCall object.
       *
       * @param signature the unique identifier for the call
       * @param argValues an array representing the values of the arguments
       *        passed to (or expected by) the call.
       */
      public RecordedCall(Signature signature, Object[] argValues) {
          super(signature, argValues);
      }
  
      /***
       * Creates a new RecordedCall object.
       *
       * @param signature the unique identifier for the call
       */
      public RecordedCall(Signature signature) {
          super(signature);
      }
  
      /***
       * Creates a new RecordedCall object which has a return value.
       *
       * @param signature the method signature for the call
       * @param argValues an array representing the values of the arguments
       *        passed to (or expected by) the call.
       * @param returnValue the value the call will return
       */
      public RecordedCall(Signature signature, Object[] argValues,
          Object returnValue) {
          super(signature, argValues, returnValue);
      }
  
      /***
       * Creates a new RecordedCall object which throws an exception.
       *
       * @param signature the method signature for the call
       * @param argValues an array representing the values of the arguments
       *        passed to (or expected by) the call.
       * @param throwable the exception the call will throw
       */
      public RecordedCall(Signature signature, Object[] argValues,
          Throwable throwable) {
          super(signature, argValues, throwable);
      }
  
      /***
       * Sets the ArgMatchers that are defined for this call.
       *
       * @param argMatchers the array of ArgMatchers to use for this call
       *
       * @throws IllegalArgumentException if the number of ArgTypes does not
       *         match the number of ArgMatchers
       */
      public void setArgMatchers(ArgMatcher[] argMatchers) {
          if (getArgTypes().length != argMatchers.length) {
              throw new IllegalArgumentException(
                  "Number of argMatchers specified ('" + argMatchers.length
                  + "') does not match the number of arguments in this call ('"
                  + getSignature() + "')");
          }
  
          this.argMatchers = argMatchers;
      }
  
      /***
       * Gets the ArgMatchers that are defined for this call (if any).
       *
       * @return the array of ArgMatchers that are defined for this call, or null
       *         if none have been defined.
       */
      public ArgMatcher[] getArgMatchers() {
          return argMatchers;
      }
 
     /***
      * Indicates if this call is invocable.  A call is invocable if has not yet
      * been invoked, or if unlimited invocation is set.
      *
      * @return true if this call is invocable
      */
     public boolean isInvocable() {
         if (hasUnlimitedInvocations() || !isInvoked()) {
             return true;
         }
 
         return false;
     }
 
     /***
      * Returns the number of times incrementInvocationCount() has been called
      * on this Call.
      *
      * @return the number of times incrementInvocationCount() has been called
      *         on this Call.
      */
     public int getInvocationCount() {
         return invocationCount;
     }
 
     /***
      * Returns true if invocation count is greater than zero.
      *
      * @return true if invocation count is greater than zero.
      */
     public boolean isInvoked() {
         if (invocationCount > 0) {
             return true;
         }
 
         return false;
     }
 
     /***
      * Set that this call can be invoked an unlimited number of times.
      *
      * @param unlimitedInvocations boolean flag.
      */
     public void setUnlimitedInvocations(boolean unlimitedInvocations) {
         this.unlimitedInvocations = unlimitedInvocations;
     }
 
     /***
      * <p>
      * Performs matching of all arguments on this Call to the specified Call,
      * based on the ArgMatchers that are defined for this call. For
      * ArgMatchers where the order is relevant (such  as GreaterThanMatcher),
      * it is important to know that the  Call is matched <strong>TO</strong>
      * the Call.  In other words, Call GreaterThan Call is checked to see if
      * the match is true.
      * </p>
      * 
      * <p>
      * Note that all matching is done based on position.  This means that that
      * all arguments and matchers must be in the same corresponding order on
      * this Call, the Call which was passed, and the ArgMatchers for this
      * Call.
      * </p>
      *
      * @param call The Call which will be matched to this Call
      *
      * @return true if the this Call matches the Call, or false if it does not
      *
      * @throws IllegalArgumentException if the signatures of the calls do not
      *         match
      *
      * @todo need to implement support for configurable default ArgMatcher,
      *       instead of hardcoding default to EqualsMatcher
      */
     public boolean hasMatchingArgs(Call call) {
         if (!getSignature().equals(call.getSignature())) {
             throw new IllegalArgumentException(
                 "Cannot perform argument matching, because the signature of this Call ('"
                 + getSignature()
                 + "') does not match the signature of the Call which was passed ('"
                 + call.getSignature() + "')");
         }
 
         // iterate through all corresponding arguments defined for 
         // this Call and the passed call, 
         // and call the corresponding ArgMatchers matches() method.
         Object[] recordedArgValues = getArgValues();
         Object[] invokedArgValues = call.getArgValues();
 
         for (int i = 0; i < recordedArgValues.length; i++) {
             ArgMatcher matcher = null;
 
             if (getArgMatchers() != null) {
                 // if ArgMatchers are defined, use them 
                 matcher = getArgMatchers()[i];
             } else {
                 // if no ArgMatchers are defined, default to EqualsMatcher
                 matcher = VM.EQUALS_MATCHER;
             }
 
             boolean argMatches =
                 matcher.matches(recordedArgValues[i], invokedArgValues[i]);
 
             if (!argMatches) {
                 return false;
             }
         }
 
         return true;
     }
 
     /***
      * Return true if this call has unlimited invocations set.
      *
      * @return true if this call has unlimited invocations set.
      */
     public boolean hasUnlimitedInvocations() {
         return unlimitedInvocations;
     }
 
     /***
      * Increments the internal invocation count for this call by one.
      */
     public void incrementInvocationCount() {
         invocationCount++;
     }
 
     /***
      * Returns true if hasMatchingSignature() and hasMatchingArgs() both return
      * true.
      *
      * @param call Call to match against
      *
      * @return true if hasMatchingSignature() and hasMatchingArgs() both return
      *         true.
      */
     public boolean matches(Call call) {
         if (!hasMatchingSignature(call)) {
             return false;
         }
 
         if (!hasMatchingArgs(call)) {
             return false;
         }
 
         return true;
     }
 }