AccessAccount.java

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.Scanner;

/**
 * The AccessAccount class opens an existing account (by name and password) so money can be
 * deposited or withdrawn. It extends Account and overrides deposit() and withdraw() so every
 * transaction is printed and logged in balanceSheet.txt. accountInfo.txt is never changed.
 */
public class AccessAccount extends Account {

    /**
     * Constructor: builds an AccessAccount from data already saved in the files.
     * @param name The name of the account holder.
     * @param accountNumber The account number.
     * @param balance The current balance from balanceSheet.txt.
     */
    public AccessAccount(String name, int accountNumber, double balance) {
        super(name, accountNumber, balance);
    }
    /**
     * Overrides Account's type.
     * @return "Access".
     */
    @Override
    public String getAccountType() {
        return "Access";
    }
    /**
     * Overrides Account's deposit: uses Account's rules, then logs the deposit and confirms it.
     * @param amount The amount to deposit.
     * @return true if the deposit went through, false otherwise.
     */
    @Override
    public boolean deposit(double amount) {
        if (!super.deposit(amount)) {
            return false;
        }
        recordTransaction("deposit", amount);
        System.out.println("The amount " + amount + " has been deposited to the account " + accountNumber);
        return true;
    }
    /**
     * Overrides Account's withdraw: uses Account's rules, then logs the withdrawal and confirms it.
     * @param amount The amount to withdraw.
     * @return true if the withdrawal went through, false otherwise.
     */
    @Override
    public boolean withdraw(double amount) {
        if (!super.withdraw(amount)) {
            return false;
        }
        recordTransaction("withdraw", amount);
        System.out.println("WITHDRAW");
        System.out.println(today());
        System.out.println("You have withdrawn " + amount + ". Now you have " + balance + " in your account");
        return true;
    }
    /**
     * Finds the saved account line for a name and password in accountInfo.txt.
     * @param name The account holder's name (any capitalization).
     * @param password The account's password.
     * @return The saved {name, password, accountID, dateOfBirth}, or null if no account matches.
     * @throws IOException If an I/O error occurs while reading the file.
     */
    private static String[] findAccount(String name, String password) throws IOException {
        File file = new File(ACCOUNT_FILE);
        if (!file.exists()) {
            return null;
        }
        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            reader.readLine(); // skip header
            String line;
            while ((line = reader.readLine()) != null) {
                String[] parts = line.split("\t");
                if (parts.length < 4) continue;
                if (parts[0].equalsIgnoreCase(name) && parts[1].equals(password)) {
                    return parts;
                }
            }
        }
        return null;
    }
    /**
     * Finds an account's current balance: the resulting balance on its last line in balanceSheet.txt.
     * @param accountNumber The account number to look for.
     * @return The current balance, or 0.0 if the account has no transactions.
     * @throws IOException If an I/O error occurs while reading the file.
     */
    private static double findBalance(int accountNumber) throws IOException {
        File file = new File(BALANCE_FILE);
        if (!file.exists()) {
            return 0.0;
        }
        double balance = 0.0;
        try (BufferedReader reader = new BufferedReader(new FileReader(file))) {
            reader.readLine(); // skip header
            String line;
            while ((line = reader.readLine()) != null) {
                String[] parts = line.split("\t");
                if (parts.length < 6) continue;
                if (Integer.parseInt(parts[1]) == accountNumber) {
                    balance = Double.parseDouble(parts[5]); // keep the latest one
                }
            }
        }
        return balance;
    }
    /**
     * Opens an existing account by prompting for the name and password.
     * @param in The Scanner object for reading user input.
     * @return The AccessAccount, or null if the name or password is wrong.
     * @throws IOException If an I/O error occurs while reading the files.
     */
    public static AccessAccount login(Scanner in) throws IOException {
        System.out.print("Enter name: ");
        String name = in.nextLine().trim();

        System.out.print("Enter password: ");
        String password = in.nextLine().trim();

        String[] saved = findAccount(name, password);
        if (saved == null) {
            System.out.println("Name or password is incorrect.");
            return null;
        }
        int accountNumber = Integer.parseInt(saved[2]);
        return new AccessAccount(saved[0], accountNumber, findBalance(accountNumber)); // use the saved name

    }
}