//  BankInterfaceTests.java  (c) 2005 Kari Laitinen

//  http://www.naturalprogramming.com

//  2005-06-07  File created.
//  2005-06-07  Last modification.

//  This program is an extended version of program BankPolymorphic.java.
//  The BankAccount class implements the two interfaces that are 
//  declared below. In the main() method, an object reference of
//  type MoneyStore is used to reference a bank account object.

interface  MoneyStore
{
   void deposit_money( double amount_to_deposit ) ;
   void withdraw_money( double amount_to_withdraw ) ;
}

interface  MoneyMover  extends  MoneyStore
{
   void transfer_money_to( BankAccount account_to_transfer_to,
                           double      amount_to_transfer ) ;
}


class  BankAccount  implements  MoneyStore, MoneyMover
{
   protected  String  account_owner ;
   protected  long    account_number ;
   protected  double  account_balance ;

   public BankAccount( String  given_account_owner,
                       long    given_account_number,
                       double  initial_balance )
   {
      account_owner    =  given_account_owner ;
      account_number   =  given_account_number ;
      account_balance  =  initial_balance  ;
   }

   public void show_account_data()
   {
      System.out.print( "\n\nB A N K   A C C O U N T   D A T A : "
                     +  "\n   Account owner :  "  +  account_owner
                     +  "\n   Account number:  "  +  account_number
                     +  "\n   Current balance: "  +  account_balance ) ;
   }

   public void deposit_money( double amount_to_deposit )
   {
      System.out.print( "\n\nTRANSACTION FOR ACCOUNT OF " +  account_owner
                     +  " (Account number " +  account_number  + ")" ) ;
      System.out.print( "\n   Amount deposited: "  +  amount_to_deposit
                     +  "\n   Old account balance: "  +  account_balance ) ;
      account_balance  =  account_balance  +  amount_to_deposit ;
      System.out.print( "   New balance: "  +  account_balance  ) ;
   }

   public void withdraw_money( double amount_to_withdraw )
   {
      System.out.print( "\n\nTRANSACTION FOR ACCOUNT OF " +  account_owner
                     +  " (Account number " +  account_number  + ")" ) ;

      if ( account_balance  <  amount_to_withdraw )
      {
         System.out.print("\n   -- Transaction not completed: "
                + "Not enough money to withdraw " + amount_to_withdraw ) ;
      }
      else
      {
         System.out.print("\n   Amount withdrawn:    "  +  amount_to_withdraw
                        + "\n   Old account balance: "  +  account_balance ) ;
         account_balance  =  account_balance  -  amount_to_withdraw ;
         System.out.print("   New balance: "  +  account_balance ) ;
      }
   }

   public void transfer_money_to( BankAccount  receiving_account,
                                  double       amount_to_transfer )
   {
      System.out.print( "\n\nTRANSACTION FOR ACCOUNT OF " +  account_owner
                     +  " (Account number " +  account_number  + ")" ) ;

      if ( account_balance  >=  amount_to_transfer )
      {
         receiving_account.account_balance  =
            receiving_account.account_balance  +  amount_to_transfer ;

         System.out.print("\n   " + amount_to_transfer + " was transferred to "
              + receiving_account.account_owner  +  " (Account no. "
              + receiving_account.account_number +  ")."
              + "\n   Balance before transfer: " +  account_balance ) ;
         account_balance  =  account_balance  -  amount_to_transfer ;
         System.out.print("   New balance:  " +  account_balance ) ;
      }
      else
      {
         System.out.print( "\n   -- Not enough money for transfer." ) ;
      }
   }
}

class  AccountWithCredit  extends  BankAccount
{
   protected  double  credit_limit ;

   public  AccountWithCredit( String  given_account_owner,
                              long    given_account_number,
                              double  initial_balance,
                              double  given_credit_limit  )
   {
      super( given_account_owner,
             given_account_number,
             initial_balance ) ;

      credit_limit  =  given_credit_limit ;
   }

   public void withdraw_money( double amount_to_withdraw )
   {
      System.out.print( "\n\nTRANSACTION FOR ACCOUNT OF " +  account_owner
                     +  " (Account number " +  account_number  + ")" ) ;

      if ( account_balance  +  credit_limit  <  amount_to_withdraw )
      {
         System.out.print(
               "\n   --  Transaction not completed: "
             + "Not enough credit to withdraw "+ amount_to_withdraw ) ;
      }
      else
      {
         System.out.print(
                "\n   Amount withdrawn:    "  +  amount_to_withdraw
              + "\n   Old account balance: "  +  account_balance ) ;
         account_balance  =  account_balance  -  amount_to_withdraw ;
         System.out.print( "   New balance: "  +  account_balance ) ;
      }
   }
}

class  RestrictedAccount  extends  BankAccount
{
   protected double  maximum_amount_to_withdraw ;

   public RestrictedAccount( String  given_account_owner,
                             long    given_account_number,
                             double  initial_balance,
                             double  given_withdrawal_limit  )
   {
      super( given_account_owner,
             given_account_number,
             initial_balance ) ;

      maximum_amount_to_withdraw  =  given_withdrawal_limit ;
   }

   public void withdraw_money( double amount_to_withdraw )
   {
      if ( amount_to_withdraw  >  maximum_amount_to_withdraw )
      {
         System.out.print(
                 "\n\nTRANSACTION FOR ACCOUNT OF " +  account_owner
              +  " (Account number " +  account_number  + ")" ) ;

         System.out.print(
                 "\n   -- Transaction not completed: Cannot withdraw "
              +  amount_to_withdraw   + "\n   -- Withdrawal limit is "
              +  maximum_amount_to_withdraw + "." ) ;
      }
      else
      {
         super.withdraw_money( amount_to_withdraw ) ;
      }
   }
}

class BankInterfaceTests
{
   public static void main( String[] not_in_use )
   {
      BankAccount  beatles_account  =
                     new  BankAccount( "John Lennon", 222222, 2000.00 ) ;

      AccountWithCredit  stones_account  =
                       new  AccountWithCredit( "Brian Jones", 333333,
                                                2000.00,  1000.00 ) ;

      RestrictedAccount   doors_account  =
                       new  RestrictedAccount( "Jim Morrison", 444444,
                                               4000.00,  1000.00 ) ;

      beatles_account.withdraw_money( 2500.00 ) ;
      stones_account.withdraw_money( 2500.00 ) ;
      doors_account.withdraw_money( 2500.00 ) ;

      MoneyStore  queen_account  = 
                       new  RestrictedAccount( "Freddie Mercury", 99999,
                                                 7000.00,  3000.00 ) ;
      queen_account.withdraw_money( 2500.00 ) ;

      //  The following statement is not possible because interface
      //  type MoneyStore does not specify method transfer_money_to().
      //  If you declare queen_account to be of type MoneyMover,
      //  the following statement will be acceptable.

      // queen_account.transfer_money_to( beatles_account, 500.00 ) ;
   }
}