// Copyright (c) 2003, Chad Woolley, All rights reserved.
   
   package org.virtualmock.call;
   
   import java.util.Iterator;
   import java.util.LinkedList;
   import java.util.List;
   import java.util.ListIterator;
   
  
  /***
   * This class represents a sequence of calls.  Calls added are stored
   * sequentially, and can be retrieved in same order they were added.  Calls
   * can also be retrieved by Signature.  Utility methods are also provided to
   * manage the queue.
   *
   * @author Chad Woolley
   */
  public class CallQueue {
      /*** Contains the calls that have been added to the queue. */
      private List calls = new LinkedList();
  
      /***
       * This is a list of the Signatures for the calls that are contained in the
       * calls list.  It is used to facilitate lookup of specific calls based on
       * signature (without having to traverse the entire calls list).
       */
      private List signatures = new LinkedList();
  
      /***
       * Gets a call based on the callId.
       *
       * @param callId the unique identifier for the call
       *
       * @return the call which matches the CallId, or null if no match was
       *         found.
       */
      public Call getCallByCallId(String callId) {
          Iterator iterator = calls.iterator();
  
          while (iterator.hasNext()) {
              Call call = (Call) iterator.next();
  
              if (call.getCallId().equals(callId)) {
                  return call;
              }
          }
  
          return null;
      }
  
      /***
       * Get all calls that have been added, in order.
       *
       * @return all calls that have been added
       */
      public List getCalls() {
          return calls;
      }
  
      /***
       * Gets the first call in the queue which has a signature matching the
       * parameter.
       *
       * @param signature the signature used to look up the call
       *
       * @return the first call in the queue which has a signature matching the
       *         parameter
       */
      public Call getFirstCallWithMatchingSignature(Signature signature) {
          int indexOfFirstCallWithMatchingSignature =
              getIndexOfFirstCallWithMatchingSignature(signature);
  
          if (indexOfFirstCallWithMatchingSignature == -1) {
              // return null if no matching call was found
              return null;
          }
  
          return (Call) calls.get(indexOfFirstCallWithMatchingSignature);
      }
  
      /***
       * Gets the index of the next call in the queue which has a signature
       * matching the parameter, starting at the specified index.
       *
       * @param startIndex the index to start looking at
       * @param signature the signature used to look up the call
       *
       * @return the next call in the queue which has a signature matching the
       *         parameter, or null if no match is found
       */
      public int getIndexOfNextCallWithMatchingSignature(int startIndex,
          Signature signature) {
          ListIterator iterator = getCalls().listIterator(startIndex);
          int callIndex = startIndex;
  
          // iterate through the list starting at the first match
          while (iterator.hasNext()) {
              Call call = (Call) iterator.next();
 
             if (call.hasMatchingSignature(signature)) {
                 return callIndex;
             }
 
             callIndex++;
         }
 
         return -1;
     }
 
     /***
      * Returns the number of calls in the queue with the specified signature.
      *
      * @param signature the signature to match
      *
      * @return the number of calls in the queue with the specified signature
      */
     public int getMatchingSignatureCount(Signature signature) {
         int matchingSignatureCount = 0;
 
         Iterator iterator = getSignatures().iterator();
 
         while (iterator.hasNext()) {
             Signature nextSignature = (Signature) iterator.next();
 
             if (nextSignature.equals(signature)) {
                 matchingSignatureCount++;
             }
         }
 
         return matchingSignatureCount;
     }
 
     /***
      * Gets the next call in the queue which has a signature matching the
      * parameter, starting at the specified index.
      *
      * @param startIndex the index to start looking at
      * @param signature the signature used to look up the call
      *
      * @return the next call in the queue which has a signature matching the
      *         parameter, or null if no match is found
      */
     public Call getNextCallWithMatchingSignature(int startIndex,
         Signature signature) {
         ListIterator iterator = getCalls().listIterator(startIndex);
 
         // iterate through the list starting at the first match
         while (iterator.hasNext()) {
             Call call = (Call) iterator.next();
 
             if (call.hasMatchingSignature(signature)) {
                 return call;
             }
         }
 
         return null;
     }
 
     /***
      * Adds a new call to the end of the queue, and also sets the
      * signatureSequence for the call.
      *
      * @param call a call to add to the queue
      */
     public void add(Call call) {
         int matchingCallCount = getMatchingSignatureCount(call.getSignature());
         int signatureSequence = ++matchingCallCount;
         call.setSignatureSequence(signatureSequence);
         calls.add(call);
         signatures.add(call.getSignature());
     }
 
     /***
      * Reinitialize by clearing out all calls.
      */
     public void clear() {
         calls.clear();
         signatures.clear();
     }
 
     /***
      * Indicates if the queue has a call matching the specified signature.
      *
      * @param signature the signature to match
      *
      * @return true if the queue has a call matching the specified signature
      */
     public boolean hasCallWithMatchingSignature(Signature signature) {
         if (getFirstCallWithMatchingSignature(signature) == null) {
             return false;
         }
 
         return true;
     }
 
     /***
      * Indicates if the queue has a call matching the specified signature.
      *
      * @param call the call to match
      *
      * @return true if the queue has a call matching the specified signature
      */
     public boolean hasCallWithMatchingSignature(Call call) {
         return hasCallWithMatchingSignature(call.getSignature());
     }
 
     /***
      * Get the number of calls in the queue.
      *
      * @return the number of calls in the queue
      */
     public int size() {
         return calls.size();
     }
 
     /***
      * Gets the index of the first call which has the same signature.
      *
      * @param signature The signature to match on
      *
      * @return the index of the first call which has the same signature
      */
     protected int getIndexOfFirstCallWithMatchingSignature(Signature signature) {
         int indexOfFirstCallWithMatchingSignature =
             getSignatures().indexOf(signature);
 
         return indexOfFirstCallWithMatchingSignature;
     }
 
     /***
      * Get the signatures for all the calls in the queue, in the same order as
      * the calls.
      *
      * @return Get the signatures for all the calls in the queue, in the same
      *         order as the calls.
      */
     protected List getSignatures() {
         return signatures;
     }
 }