the_big_one/src/main/java/jesse/keeblarcraft/BankMgr/BankManager.java

package jesse.keeblarcraft.BankMgr;

import java.util.HashMap;
import java.util.List;
import java.util.ArrayList;
import java.util.Map.Entry;

import jesse.keeblarcraft.ConfigMgr.ConfigManager;
import net.minecraft.server.network.ServerPlayerEntity;
import net.minecraft.text.Text;

// The bank manager takes care of routing any and all transactions throughout the server.
// It is a singleton object that is active throughout the mods lifetime and will cache players accounts
// when they log in to avoid constant look-ups through JSON.
public final class BankManager {
    private static BankManager static_inst;

    public static BankManager GetInstance() {
        if (static_inst == null) {
            static_inst = new BankManager();
        }
        return static_inst;
    }

    private static Integer KEEBLARCRAFT_SERVER_BANK_ID = 1000;

    ConfigManager config = new ConfigManager();

    private HashMap<Integer, IndividualBank> banks = new HashMap<Integer, IndividualBank>();
    private HashMap<String, Integer> bankNameFastMap = new HashMap<String, Integer>();

    public BankManager() {}

    public void InitializeBanks() {
        banks.put(KEEBLARCRAFT_SERVER_BANK_ID, new IndividualBank(Integer.toString(KEEBLARCRAFT_SERVER_BANK_ID), "KeeblarcraftGlobal"));

        // Initialize fast map
        for (Entry<Integer, IndividualBank> bank : banks.entrySet()) {
            bankNameFastMap.put(bank.getValue().GetBankName(), bank.getValue().GetRoutingNumber());
        }
    }

    public List<String> GetAllBankNames() {
        List<String> names = new ArrayList<String>();

        // Iterate through all banks in the list to get their names
        for (Entry<Integer, IndividualBank> bank : banks.entrySet()) {
            names.add(bank.getValue().GetBankName());
        }
        return names;
    }

    public IndividualBank GetBankByRoutingNumber(Integer number) {
        IndividualBank bank = null;
        if (banks.containsKey(number)) {
            bank = banks.get(number);
        }
        return bank;
    }

    public IndividualBank GetBankByName(String name) {
        IndividualBank bank = null;
        System.out.println("GetBankByName called with value " + name);
        if (bankNameFastMap.containsKey(name)) {
            System.out.println("Value of bank with name is " + bankNameFastMap.get(name));
            System.out.println("Banks map size is " + banks.size());
            bank = banks.get(bankNameFastMap.get(name));
        }

        System.out.println("Returning bank information");
        return bank;
    }

    // Change the funds of an account from an administrative perspective
    public void AdminChangeFunds(ServerPlayerEntity initiator, String accountId, Integer amount, String changeType, String optionalReason) {
        // Check to make sure account id exists
        Integer routingNum = AccountNumberGenerator.GetRoutingNumberFromId(accountId);
        IndividualBank bankFromRout = GetBankByRoutingNumber(routingNum);

        System.out.println("Is bank null? " + (bankFromRout == null ? "YES" : "NO"));
        System.out.println("Bank specified: " + bankFromRout);
        System.out.println("Routing number: " + routingNum);
        // Verify bank exists
        if (bankFromRout != null) {
            // Verify account exists
            System.out.println("accountNumber is " + accountId);
            String accountNumber = AccountNumberGenerator.GetAccountNumberFromId(accountId);
            System.out.println("changeType is " + changeType);

            switch (changeType) {
                case "add":
                    bankFromRout.AddMoneyToAccount(accountNumber, amount);
                    break;
                case "subtract":
                    bankFromRout.SubtractMoneyFromAccount(accountNumber, amount);
                    break;
                case "set":
                    bankFromRout.SetMoneyOnAccount(accountNumber, amount);
                    break;
                default:
                    System.out.println("The operation that was specified by the developer does not exist. Valid operations are add/subtract/set");
                    break;
            }
        } else {
            initiator.sendMessage(Text.of("That bank does not exist!"));
        }
    }

    public void InitiateBankFundsTransfer(String fromAccount, String toAccount) {

    }

    public void InitiateBankAccountClosure(String bankIdentifier, ServerPlayerEntity player, String bankAccountId) {

    }

    public void InitiateBankAccountCreation(String bankIdentifier, ServerPlayerEntity player, String accountType) {
        Boolean success = false;
        System.out.println("initiating bank creation");
        boolean defaultServerBank = bankIdentifier == null || bankIdentifier == "";
        System.out.println("value of bankIdentifier is " + defaultServerBank);

        System.out.println("The player name is " + player.getDisplayName().getString());

        // DEBUG

        System.out.println("BANK NAME: " + banks.get(KEEBLARCRAFT_SERVER_BANK_ID).GetBankName());
        System.out.println("BANK BALANCE: " + banks.get(KEEBLARCRAFT_SERVER_BANK_ID).GetBankBalance());

        // DEBUG END

        // Create an account via the server-owned bank account
        if (defaultServerBank) {
            success = banks.get(KEEBLARCRAFT_SERVER_BANK_ID).CreateAccount(player.getUuidAsString(), player.getDisplayName().getString(), accountType);
        } else {
            System.out.println("Creating bank on non-server owned bank");
            // Create an account via a specified bank identifier
            Integer routingNumber = Integer.parseInt(bankIdentifier);

            if (banks.containsKey(routingNumber)) {
                banks.get(routingNumber).CreateAccount(player.getUuidAsString(), player.getDisplayName().getString(), accountType);
            } else {
                player.sendMessage(Text.of("That bank does not exist"));
            }
        }

        if (success) {
            player.sendMessage(Text.of("The banking operation was successful and your banking information has been updated"));
        } else {
            player.sendMessage(Text.of("The banking operating FAILED. You may need to visit the bank for more information!"));
        }
    }
}