Main.java

package com.transactions;

import com.transactions.exceptions.InsufficientFundsException;
import com.transactions.models.BankAccount;
import com.transactions.transactions.BaseTransaction;
import com.transactions.transactions.DepositTransaction;
import com.transactions.transactions.WithdrawalTransaction;
import java.util.Calendar;

public class Main {

    public static void main(String[] args) {

        // create bank accounts for testing
        BankAccount account1 = new BankAccount("ACC001", "Alice Wanjiku", 10000.00);
        BankAccount account2 = new BankAccount("ACC002", "Bob Otieno", 500.00);
        BankAccount account3 = new BankAccount("ACC003", "Carol Mwangi", 0.00);

        System.out.println("===== Q1: Testing BaseTransaction =====");

        BaseTransaction baseTransaction = new BaseTransaction(200.00, Calendar.getInstance());
        System.out.println("Amount: " + baseTransaction.getAmount());
        System.out.println("ID: " + baseTransaction.getTransactionID());
        System.out.println("Date: " + baseTransaction.getDate().getTime());

        try {
            baseTransaction.apply(account1);
        } catch (InsufficientFundsException e) {
            System.out.println("Exception: " + e.getMessage());
        }

        System.out.println("Balance after base apply (should be unchanged): " + account1.getBalance());


        System.out.println("\n===== Q2: Testing DepositTransaction =====");

        DepositTransaction deposit = new DepositTransaction(5000.00, Calendar.getInstance());
        try {
            deposit.apply(account1);
        } catch (InsufficientFundsException e) {
            System.out.println("Exception: " + e.getMessage());
        }
        System.out.println("Balance after deposit: " + account1.getBalance());


        System.out.println("\n===== Q2: Testing WithdrawalTransaction and reverse() =====");

        WithdrawalTransaction withdrawal = new WithdrawalTransaction(3000.00, Calendar.getInstance());
        try {
            withdrawal.apply(account1);
        } catch (InsufficientFundsException e) {
            System.out.println("Exception: " + e.getMessage());
        }
        System.out.println("Balance after withdrawal: " + account1.getBalance());

        boolean reversed = withdrawal.reverse();
        System.out.println("Reversal successful: " + reversed);
        System.out.println("Balance after reversal: " + account1.getBalance());

        // try to reverse again - should fail
        withdrawal.reverse();


        System.out.println("\n===== Q3: Testing InsufficientFundsException with throws =====");

        WithdrawalTransaction bigWithdrawal = new WithdrawalTransaction(2000.00, Calendar.getInstance());
        try {
            bigWithdrawal.apply(account2);
        } catch (InsufficientFundsException e) {
            System.out.println("Caught exception: " + e.getMessage());
        }
        System.out.println("Bob balance unchanged: " + account2.getBalance());


        System.out.println("\n===== Q3: Testing overloaded apply() with try-catch-finally =====");

        // Bob has 500, trying to withdraw 2000 - should do partial withdrawal
        WithdrawalTransaction partialW = new WithdrawalTransaction(2000.00, Calendar.getInstance());
        partialW.apply(account2, true);
        System.out.println("Amount not withdrawn: " + partialW.getAmountNotWithdrawn());

        // Carol has 0 balance - should be caught inside the method
        System.out.println("\nTesting with zero balance account:");
        WithdrawalTransaction zeroW = new WithdrawalTransaction(500.00, Calendar.getInstance());
        zeroW.apply(account3, true);


        System.out.println("\n===== Q4: Testing polymorphism with type casting =====");

        BankAccount testAccount = new BankAccount("ACC004", "David Kamau", 8000.00);

        // upcast DepositTransaction to BaseTransaction reference
        // this demonstrates late binding - the JVM calls DepositTransaction.apply() at runtime
        BaseTransaction btDeposit = new DepositTransaction(1000.00, Calendar.getInstance());
        System.out.println("Runtime type: " + btDeposit.getClass().getSimpleName());
        try {
            btDeposit.apply(testAccount); // late binding - calls DepositTransaction.apply()
        } catch (InsufficientFundsException e) {
            System.out.println("Exception: " + e.getMessage());
        }

        // upcast WithdrawalTransaction to BaseTransaction reference
        BaseTransaction btWithdrawal = new WithdrawalTransaction(2000.00, Calendar.getInstance());
        System.out.println("Runtime type: " + btWithdrawal.getClass().getSimpleName());
        try {
            btWithdrawal.apply(testAccount); // late binding - calls WithdrawalTransaction.apply()
        } catch (InsufficientFundsException e) {
            System.out.println("Exception: " + e.getMessage());
        }

        // downcast back to WithdrawalTransaction to access reverse()
        if (btWithdrawal instanceof WithdrawalTransaction) {
            WithdrawalTransaction wt = (WithdrawalTransaction) btWithdrawal;
            wt.reverse();
        }

        System.out.println("David final balance: " + testAccount.getBalance());
    }
}