import java.util.Random;
import java.util.List;
import java.util.Set;
import java.util.Iterator;

/**
    Tests the bank classes of Assignment 9, CS 49J, SJSU, Spring 2009
     @author Jeff Smith
     @version final version for the assigment 
 */

public class A9
{

      // the number of accounts per bank that will
      //   be used in certain tests.
      
        private static int numberOfAccounts = 1000;

      // for recording of the start time of a test
      //   sequence
      
        private static long startTime;
        
      // a list of names for account holders
      
        private static String[] holderNames
          = new String[numberOfAccounts];
        

    /**
         Initialize the timer
     */
    
    public static void startTimer()                               {
      startTime = System.nanoTime();                              }
 

    /**
        Get the elapsed time in microseconds since
          the timer was last initialized
        @return this elapsed time
     */  
    
    public static long getElapsedTime()                           {
      return (System.nanoTime()-startTime)/1000;                  }
      
      
   /**
       Construct a random string of length 5 with vowels 
         in the 2nd and 4th positions.  Not all letters
         are allowed to occur.
       @param r a Random object to use for the random selection  
       @return the randomly generated string
    */   
   
   private static String getRandomName(Random r)                  {
     String vowels = "aeiou";
     String cons = "bcdfghklmnprstvz";
     String consUpper = "BCDFGHKLMNPRSTVZ";
     StringBuffer buffer = new StringBuffer();
     buffer.append(
       consUpper.charAt(r.nextInt(consUpper.length())));
     buffer.append(vowels.charAt(r.nextInt(vowels.length())));
     buffer.append(cons.charAt(r.nextInt(cons.length())));
     buffer.append(vowels.charAt(r.nextInt(vowels.length())));
     buffer.append(cons.charAt(r.nextInt(cons.length())));
     return new String(buffer);                                   }

     
   /**
        Tests the methods of the Bank class on a 
          given bank.  Prints various intermediate
          total balances.
        @param bank the given bank
   */
    
    public static void test1(Bank bank)                           {    
      try                                                 {
        System.out.println(bank.getTotalBalance());
        bank.addCheckingAccount(
           "James", 0);                                   }
      catch (IllegalArgumentException e)                  { 
        System.out.println(e.getMessage());               }
      try                                                 {
        bank.addSavingsAccount(
           "Madison", 0, 2.0);                            }
      catch (IllegalArgumentException e)                  { 
        System.out.println(e.getMessage());               }
      try                                                 {
        bank.addCheckingAccount(
           "Jackson", -1);                                }
      catch (IllegalArgumentException e)                  { 
        System.out.println(e.getMessage());               }
      try                                                 {
        bank.addSavingsAccount(
           "Tyler", -100, 3.0);                           }
      catch (IllegalArgumentException e)                  { 
        System.out.println(e.getMessage());               }
      try                                                 {
        bank.addSavingsAccount(
           "Taylor", 0, -2.0);                            }
      catch (IllegalArgumentException e)                  { 
        System.out.println(e.getMessage());               }
      try                                                 {
        bank.addSavingsAccount(
           null, -100, 3.0);                              }
      catch (IllegalArgumentException e)                  { 
        System.out.println(e.getMessage());               }
      try                                                 {
        bank.addSavingsAccount(
           null, 0, -2.0);                                }
      catch (IllegalArgumentException e)                  { 
        System.out.println(e.getMessage());               }
        bank.deposit(100, new AccountHolder("James"));
        bank.deposit(1000, new AccountHolder("Madison"));
        System.out.println(bank.getTotalBalance());
        bank.addInterestToAll();
        System.out.println(bank.getTotalBalance());
        bank.deductFeesFromAll();        
        System.out.println(bank.getTotalBalance());
        bank.withdraw(1, new AccountHolder("James"));
        bank.withdraw(1, new AccountHolder("Madison"));
        bank.withdraw(1, new AccountHolder("Jeff"));
        bank.deposit(4, new AccountHolder("Jeff"));
        System.out.println(bank.getTotalBalance());
        System.out.println(
            bank.getBalance(new AccountHolder("Jeff")));
        if (bank.removeAccount(new AccountHolder("Jeff")))
          System.out.println("account removed");
        else  
          System.out.println("can't remove account");
      try                                                 {
        bank.withdraw(1000, new AccountHolder("James"));  }                        
      catch (IllegalArgumentException e)                  { 
        System.out.println(e.getMessage());               }
        System.out.println(bank.getTotalBalance());               }

        
   /**
        Tests the methods of the Bank class on a 
          given bank by creating many accounts
        @param bank the given bank
        @param isReportWanted tells whether attempts
          at duplicate entry of names are to be reported
   */
    
    public static void test2(Bank bank, boolean isReportWanted)   {    
        boolean wasAdded;
        for (int i=0; i<numberOfAccounts; i++)               {
          wasAdded = bank.addCheckingAccount(
                       holderNames[i], 10*i);      
          if (isReportWanted && !wasAdded)
            System.out.println("not added: " +
               holderNames[i] + " " + 10*i);                 }    } 
 
   /**
        Tests the methods of the Bank class on a 
          given bank by creating many accounts
          and getting the total balance.
        @param bank the given bank
        @param isReportWanted tells whether attempts
          at duplicate entry of names are to be reported
        @return the final total balance
   */
    
    public static double test3(Bank bank, boolean isReportWanted)  {    
        boolean wasAdded;
        for (int i=0; i<numberOfAccounts; i++)               {
          wasAdded = bank.addCheckingAccount(
                       holderNames[i], 10*i);                
          if (isReportWanted && !wasAdded)
            System.out.println("not added: " +
               holderNames[i] + " " + 10*i);                 }
        return bank.getTotalBalance();                            } 
 
        
   /**
        Tests the methods of the Bank class on a 
          given bank by creating many accounts,
          creating an unsorted list of account holders,
          and then getting the total balance.
        @param bank the given bank
        @param isReportWanted tells whether the first
          few account holders are to be printed
        @return the final total balance
   */
    
    public static double test4(Bank bank, boolean isReportWanted) {    
      for (int i=0; i<numberOfAccounts; i++)                  {
        bank.addCheckingAccount(
          holderNames[i], 10*i);                              }
      Set<AccountHolder> holders = 
        bank.getAccountHolders();
      if (isReportWanted)                                     {
        Iterator<AccountHolder> it = holders.iterator();
        for (int i=0; i<numberOfAccounts/100; i++)
          System.out.print(it.next() + " ");
        System.out.println();                                 }
      return bank.getTotalBalance();                              } 
          
   /**
        Tests the methods of the Bank class on a 
          given bank by creating many accounts,
          creating an sorted list of account holders,
          and then getting the total balance.
        @param bank the given bank
        @param isReportWanted tells whether the first
          few account holders are to be printed
        @return the final total balance
   */
    
    public static double test5(Bank bank, boolean isReportWanted) {
      for (int i=0; i<numberOfAccounts; i++)               {
        bank.addCheckingAccount(
          holderNames[i], 10*i);                              }
      List<AccountHolder> holders = 
        bank.getSortedAccountHolders();
      if (isReportWanted)                                     {
        Iterator<AccountHolder> it = holders.iterator();
        for (int i=0; i<numberOfAccounts/100; i++)
          System.out.print(it.next() + " ");
        System.out.println();                                 }
      return bank.getTotalBalance();                      } 
          

    /**   
        Tests the methods of the Bank class on a 
          given bank by creating many accounts
          and removing all, in order of their 
          creation, then getting the total balance.
        @param bank the given bank
        @param r a random object used for selection
        @param isReportWanted tells whether attempts
          at removal of missing names are to be reported
        @return the final total balance
   */
    
    public static double test6(Bank bank, Random rand,
                  boolean isReportWanted)                         {    
        boolean wasRemoved;
        for (int i=0; i<numberOfAccounts; i++)       {
          bank.addCheckingAccount(
            holderNames[i], 10*i);                   }
        for (int i=0; i<numberOfAccounts; i++)       {
          wasRemoved = bank.removeAccount(
            new AccountHolder(holderNames[i])); 
          if (isReportWanted && !wasRemoved)
            System.out.println("not removed: " +
               holderNames[i]);                      }
        return bank.getTotalBalance();                            } 
    
          
   /**
        Tests the methods of the Bank class.
        Performs one functionality test and 
          six timing tests.   
        @param args is ignored
     */
    
    public static void main(String[] args)                        {

        Random rand = new Random(9);
        for (int i=0; i<numberOfAccounts; i++)               
          holderNames[i] = getRandomName(rand);
               
        System.out.println("        " + 
          "testing account functionality, no timing");
        
        TreeBank tBank = new TreeBank();
        test1(tBank);
        System.out.println();
        
        HashBank hBank = new HashBank();
        test1(hBank);
        System.out.println();

        System.out.println("        " + 
          "testing & timing addition of accounts");
        System.out.println("        " + 
          "without & then with computation of total balance");
        System.out.println();
                
       long totalTime = 0;  
       long totalTime2 = 0; 
       double result1 = 0;
       double result2 = 0;
       for (int i=1; i<=10; i++)                           {
          tBank = new TreeBank();
          startTimer();
          test2(tBank, i==1);
          totalTime = totalTime + getElapsedTime();        }
        for (int i=1; i<=10; i++)                          {
          hBank = new HashBank();
          startTimer();
          test2(hBank, i==1);
          totalTime2 = totalTime2 + getElapsedTime();      }
        System.out.println(result1 + " " + result2 + " " +
                         "  tree time: " + totalTime +
                         "  hashed time: " + totalTime2);
        System.out.println();
     
       totalTime = 0;  
       totalTime2 = 0; 
       for (int i=1; i<=10; i++)                           {
          tBank = new TreeBank();
          startTimer();
          result1 = test3(tBank, i==1);
          totalTime = totalTime + getElapsedTime();        }
        for (int i=1; i<=10; i++)                          {
          hBank = new HashBank();
          startTimer();
          result2 = test3(hBank, i==1);
          totalTime2 = totalTime2 + getElapsedTime();      }
        System.out.println(result1 + " " + result2 + " " +
                         "  tree time: " + totalTime +
                         "  hashed time: " + totalTime2);
        System.out.println();

        System.out.println("        " + 
          "also testing getting of account holders");
        System.out.println("        " + 
          "unsorted first, then sorted");
        System.out.println();

       totalTime = 0;  
       totalTime2 = 0; 
       for (int i=1; i<=10; i++)                           {
          tBank = new TreeBank();
          startTimer();
          result1 = test4(tBank, i==1);
          totalTime = totalTime + getElapsedTime();        }
        for (int i=1; i<=10; i++)                          {
          hBank = new HashBank();
          startTimer();
          result2 = test4(hBank, i==1);
          totalTime2 = totalTime2 + getElapsedTime();      }
        System.out.println(result1 + " " + result2 + " " +
                         "  tree time: " + totalTime +
                         "  hashed time: " + totalTime2);
        System.out.println();
                         
       totalTime = 0;  
       totalTime2 = 0; 
       for (int i=1; i<=10; i++)                           {
          tBank = new TreeBank();
          startTimer();
          result1 = test5(tBank, i==1);
          totalTime = totalTime + getElapsedTime();        }
        for (int i=1; i<=10; i++)                          {
          hBank = new HashBank();
          startTimer();
          result2 = test5(hBank, i==1);
          totalTime2 = totalTime2 + getElapsedTime();      }
        System.out.println(result1 + " " + result2 + " " +
                         "  tree time: " + totalTime +
                         "  hashed time: " + totalTime2);   
        System.out.println();

        System.out.println("        " + 
          "testing & timing addition, traversal & random removal of accounts");
        System.out.println();

       totalTime = 0;  
       totalTime2 = 0; 
       for (int i=1; i<=10; i++)                           {
          tBank = new TreeBank();
          startTimer();
          result1 = test6(tBank, new Random(9), i==1);
          totalTime = totalTime + getElapsedTime();        }
        for (int i=1; i<=10; i++)                          {
          hBank = new HashBank();
          startTimer();
          result2 = test6(hBank, new Random(9), i==1);
          totalTime2 = totalTime2 + getElapsedTime();      }
        System.out.println();
        System.out.println(result1 + " " + result2 + " " +
                         "  tree time: " + totalTime +
                         "  hashed time: " + totalTime2);
   }    

}