// Copyright (c) 2003, Chad Woolley, All rights reserved.
   
   package org.virtualmock.call;
   
   import java.util.ArrayList;
   import java.util.List;
   import junit.framework.TestCase;
   import org.virtualmock.Constants;
   import org.virtualmock.matcher.ArgMatcher;
  
  
  /***
   * Manages recorded and invoked calls.
   *
   * @author Chad Woolley
   * @version $Revision: 1.37 $
   */
  public class CallManager {
      private InvokedCallQueue invokedCallQueue = null;
      private List mockedClasses = null;
  
      // Commented for Hansel
      // private Logger logger = Logger.getLogger(CallManager.class.getName());
  
      /*** The last call that was recorded. */
      private RecordedCall lastCall = null;
      private RecordedCallQueue recordedCallQueue = null;
      private TestCase testCase = null;
      private int phase = 0;
  
      /***
       * Creates a new CallManager object.
       *
       * @param invokedCallQueue the
       * @param recordedCallQueue DOCUMENT ME! (Constructor Parameter)
       */
      public CallManager(InvokedCallQueue invokedCallQueue,
          RecordedCallQueue recordedCallQueue) {
          this.invokedCallQueue = invokedCallQueue;
          this.recordedCallQueue = recordedCallQueue;
          init();
      }
  
      /***
       * Indicates if calls are being mocked for the specified class.
       *
       * @param className The class which is being checked to see if calls are
       *        being mocked for it
       *
       * @return true if the class is being mocked, false if it is not
       */
      public boolean isClassMocked(String className) {
          if (mockedClasses.contains(className)) {
              return true;
          }
  
          return false;
      }
  
      /***
       * Returns the last call that was recorded.
       *
       * @return the last call that was recorded
       */
      public RecordedCall getLastCall() {
          return lastCall;
      }
  
      /***
       * Returns a recorded mock call which matches the specified invoked call,
       * or null if none match.
       *
       * @param invokedCall the invoked call to match
       *
       * @return DOCUMENT ME! (Method Return Value)
       */
      public RecordedCall getMatchingCall(InvokedCall invokedCall) {
          return recordedCallQueue.getMatchingCall(invokedCall);
      }
  
      /***
       * Set the phase that VirtualMock is currently in.
       *
       * @param phase the phase that VirtualMock is currently in
       */
      public void setPhase(int phase) {
          this.phase = phase;
      }
  
      /***
       * Indicates if VirtualMock is in the Playback phase.
       *
       * @return true if VirtualMock is in the Record phase
       */
      public boolean isPlaybackPhase() {
          return phase == Constants.PLAYBACK_PHASE;
      }
  
      /***
      * Indicates if VirtualMock is in the Record phase.
      *
      * @return true if VirtualMock is in the Record phase
      */
     public boolean isRecordPhase() {
         return phase == Constants.RECORD_PHASE;
     }
 
     /***
      * Accessor.
      *
      * @return the recorded call queue
      */
     public RecordedCallQueue getRecordedCallQueue() {
         return recordedCallQueue;
     }
 
     /***
      * Convenience method to retrieve calls list for the RecordedCallQueue.
      *
      * @return the calls list of the recorded call queue
      */
     public List getRecordedCalls() {
         return recordedCallQueue.getCalls();
     }
 
     /***
      * Set the TestCase being executed.
      *
      * @param case1 the TestCase to set
      */
     public void setTestCase(TestCase case1) {
         testCase = case1;
     }
 
     /***
      * Get the TestCase being executed.
      *
      * @return the TestCase being executed
      */
     public TestCase getTestCase() {
         return testCase;
     }
 
     /***
      * Gets all uninvoked calls from the RecordedCallQueue.
      *
      * @return An array of all uninvoked RecordedCalls
      */
     public RecordedCall[] getUninvokedCalls() {
         return recordedCallQueue.getUninvokedCalls();
     }
 
     /***
      * Indicates if VirtualMock is in the Verify phase.
      *
      * @return true if VirtualMock is in the Verify phase
      */
     public boolean isVerifyPhase() {
         return phase == Constants.VERIFY_PHASE;
     }
 
     /***
      * Indicates that all calls should be mocked for the specified class.
      *
      * @param classToMock The class for which to mock calls
      */
     public void addMockClass(String classToMock) {
         mockedClasses.add(classToMock);
     }
 
     /***
      * This method is called from the advice to indicate when a call is
      * invoked.
      *
      * @param invokedCall the call that was invoked
      */
     public void indicateCalled(InvokedCall invokedCall) {
         putInvokedCall(invokedCall);
 
         // flag the call as invoked in recordedCallQueue queue
         RecordedCall nextMatchingUninvokedCall = getMatchingCall(invokedCall);
 
         if (nextMatchingUninvokedCall != null) {
             nextMatchingUninvokedCall.incrementInvocationCount();
         }
     }
 
     /***
      * Define the ArgMatchers for the last recorded call, which should have the
      * same number of arguments as elements in the array.
      *
      * @param argMatchers The array of ArgMatchers that VirtualMock will use to
      *        match the arguments when the last recorded call is invoked.
      */
     public void recordArgMatchers(ArgMatcher[] argMatchers) {
         getLastCall().setArgMatchers(argMatchers);
     }
 
     /***
      * Records a call which will be mocked.
      *
      * @param signature the unique identifier for the call
      * @param argValues values of arguments for the call
      *
      * @return the newly recorded call
      */
     public RecordedCall recordCall(Signature signature, Object[] argValues) {
         // DEBUG: disabled for Hansel
         //        if (logger.isDebugEnabled()) {
         //            logger.debug("in recordCall, call='" + signature +
         //                "', argValues='" + argValues + "', recordedCallQueue size=" +
         //                recordedCallQueue.size());
         //        }
         RecordedCall recordedCall = null;
         recordedCall = new RecordedCall(signature, argValues);
 
         recordedCallQueue.add(recordedCall);
 
         // DEBUG: disabled for Hansel
         //        if (logger.isDebugEnabled()) {
         //            logger.debug("exiting recordCall, " +
         //                "added to queue with callId=" +
         //                signature + ", recordedCallQueue size=" +
         //                recordedCallQueue.size());
         //        }
         // keep track of the last call that was recorded
         lastCall = recordedCall;
 
         return recordedCall;
     }
 
     /***
      * Records a return value for the most recently recorded call.
      *
      * @param returnValue the value to return when the call is invoked
      */
     public void recordReturnValueForLastCall(Object returnValue) {
         lastCall.setReturnValue(returnValue);
     }
 
     /***
      * Records a throwable to be thrown for the most recently recorded call.
      *
      * @param throwable the throwable to throw when the call is invoked
      */
     public void recordThrowableForLastCall(Throwable throwable) {
         lastCall.setThrowable(throwable);
     }
 
     /***
      * Initializes the CallManager by clearing the RecordedCallQueue and
      * InvokedCallQueue, and setting phase to RECORD_PHASE.
      */
     protected void init() {
         setPhase(Constants.RECORD_PHASE);
         mockedClasses = new ArrayList();
         recordedCallQueue.clear();
         invokedCallQueue.clear();
     }
 
     /***
      * Puts an InvokedCall on the InvokedCallQueue.
      *
      * @param invokedCall the call that was invoked, and should be put on the
      *        InvokedCallQueue
      */
     private void putInvokedCall(InvokedCall invokedCall) {
         // add this invoked call to the end of the queue
         invokedCallQueue.add((InvokedCall) invokedCall);
 
         // DEBUG: disabled for Hansel
         //        if (logger.isDebugEnabled()) {
         //            logger.debug("exiting putInvokedCall, queued call = " +
         //                invokedCall.toString());
         //        }
     }
 }