clsBankClient.h

/**
 * @file clsBankClient.h
 * @author Bank System Developer
 * @version 1.0
 * @date 2024
 * 
 * @brief Bank Client class for managing client accounts and banking operations
 * 
 * This class represents a bank client with account information and banking
 * functionality. It inherits from clsPerson to include personal information
 * and adds banking-specific features like account numbers, PIN codes, and
 * account balances.
 * 
 * Features:
 * - Complete CRUD operations for client data
 * - File-based data persistence
 * - Banking transactions (deposit, withdraw)
 * - Account balance management
 * - Soft delete functionality
 */

#pragma once
#include <iostream>
#include <string>
#include "clsPerson.h"
#include "clsString.h"
#include <vector>
#include <fstream>

using namespace std;

/**
 * @class clsBankClient
 * @brief Represents a bank client with account and personal information
 * 
 * This class manages all aspects of a bank client including personal details
 * (inherited from clsPerson) and banking-specific information like account
 * numbers, PIN codes, and balances. It provides methods for data persistence,
 * banking transactions, and account management.
 */
class clsBankClient : public clsPerson
{
private:

    /**
     * @enum enMode
     * @brief Defines the operational mode of the client object
     */
    enum enMode { 
        EmptyMode = 0,    ///< Object is empty/uninitialized
        UpdateMode = 1,   ///< Object is in update mode for existing client
        AddNewMode = 2    ///< Object is in add mode for new client
    };
    
    enMode _Mode;                    ///< Current operational mode of the object
    string _AccountNumber;           ///< Unique account number identifier
    string _PinCode;                 ///< PIN code for account access (stored in plain text)
    float _AccountBalance;           ///< Current account balance
    bool _MarkedForDelete = false;   ///< Flag indicating if record is marked for deletion

    /**
     * @brief Converts a delimited string line to a clsBankClient object
     * 
     * Parses a line from the data file and creates a clsBankClient object
     * with the extracted data. The line format is:
     * FirstName#//#LastName#//#Email#//#Phone#//#AccountNumber#//#PinCode#//#Balance
     * 
     * @param Line The delimited string line from the data file
     * @param Seperator The delimiter used to separate fields (default: "#//#")
     * @return clsBankClient object created from the parsed data
     */
    static clsBankClient _ConvertLinetoClientObject(string Line, string Seperator = "#//#")
    {
        vector<string> vClientData;
        vClientData = clsString::Split(Line, Seperator);

        return clsBankClient(enMode::UpdateMode, vClientData[0], vClientData[1], vClientData[2],
            vClientData[3], vClientData[4], vClientData[5], stod(vClientData[6]));

    }

    /**
     * @brief Converts a clsBankClient object to a delimited string line
     * 
     * Serializes a clsBankClient object into a string format suitable for
     * storage in the data file. The output format is:
     * FirstName#//#LastName#//#Email#//#Phone#//#AccountNumber#//#PinCode#//#Balance
     * 
     * @param Client The clsBankClient object to serialize
     * @param Seperator The delimiter to use between fields (default: "#//#")
     * @return String representation of the client data
     */
    static string _ConvertClientObjectToLine(clsBankClient Client, string Seperator = "#//#")
    {
        string stClientRecord = "";
        stClientRecord += Client.FirstName + Seperator;
        stClientRecord += Client.LastName + Seperator;
        stClientRecord += Client.Email + Seperator;
        stClientRecord += Client.Phone + Seperator;
        stClientRecord += Client.AccountNumber() + Seperator;
        stClientRecord += Client.PinCode + Seperator;
        stClientRecord += to_string(Client.AccountBalance);

        return stClientRecord;
    }

    /**
     * @brief Loads all client data from the Clients.txt file
     * 
     * Reads the entire Clients.txt file and converts each line into
     * a clsBankClient object, returning a vector of all clients.
     * 
     * @return vector<clsBankClient> Vector containing all client records
     * @note Returns empty vector if file cannot be opened or is empty
     */
    static vector<clsBankClient> _LoadClientsDataFromFile()
    {
        vector<clsBankClient> vClients;

        fstream MyFile;
        MyFile.open("Clients.txt", ios::in); // Read mode

        if (MyFile.is_open())
        {
            string Line;
            while (getline(MyFile, Line))
            {
                clsBankClient Client = _ConvertLinetoClientObject(Line);
                vClients.push_back(Client);
            }
            MyFile.close();
        }

        return vClients;
    }

    static void _SaveCleintsDataToFile(vector <clsBankClient> vClients)
    {

        fstream MyFile;
        MyFile.open("Clients.txt", ios::out);//overwrite

        string DataLine;

        if (MyFile.is_open())
        {

            for (clsBankClient C : vClients)
            {
                if (C.MarkedForDeleted() == false)
                {
                    //we only write records that are not marked for delete.  
                    DataLine = _ConvertClientObjectToLine(C);
                    MyFile << DataLine << endl;

                }

            }

            MyFile.close();

        }

    }

    void _Update()
    {
        vector <clsBankClient> _vClients;
        _vClients = _LoadClientsDataFromFile();

        for (clsBankClient& C : _vClients)
        {
            if (C.AccountNumber() == AccountNumber())
            {
                C = *this;
                break;
            }

        }

        _SaveCleintsDataToFile(_vClients);

    }

    void _AddNew()
    {

        _AddDataLineToFile(_ConvertClientObjectToLine(*this));
    }

    void _AddDataLineToFile(string  stDataLine)
    {
        fstream MyFile;
        MyFile.open("Clients.txt", ios::out | ios::app);

        if (MyFile.is_open())
        {

            MyFile << stDataLine << endl;

            MyFile.close();
        }

    }

    static clsBankClient _GetEmptyClientObject()
    {
        return clsBankClient(enMode::EmptyMode, "", "", "", "", "", "", 0);
    }

public:

    /**
     * @brief Constructor for clsBankClient
     * 
     * Initializes a new clsBankClient object with the provided information.
     * Inherits personal information from clsPerson and adds banking-specific data.
     * 
     * @param Mode The operational mode (EmptyMode, UpdateMode, or AddNewMode)
     * @param FirstName Client's first name
     * @param LastName Client's last name
     * @param Email Client's email address
     * @param Phone Client's phone number
     * @param AccountNumber Unique account number identifier
     * @param PinCode PIN code for account access
     * @param AccountBalance Initial account balance
     */
    clsBankClient(enMode Mode, string FirstName, string LastName,
        string Email, string Phone, string AccountNumber, string PinCode,
        float AccountBalance) :
        clsPerson(FirstName, LastName, Email, Phone)
    {
        _Mode = Mode;
        _AccountNumber = AccountNumber;
        _PinCode = PinCode;
        _AccountBalance = AccountBalance;
    }

    /**
     * @brief Checks if the client object is empty/uninitialized
     * 
     * @return true if the object is in EmptyMode, false otherwise
     */
    bool IsEmpty()
    {
        return (_Mode == enMode::EmptyMode);
    }

    /**
     * @brief Checks if the client record is marked for deletion
     * 
     * @return true if marked for deletion, false otherwise
     */
    bool MarkedForDeleted()
    {
        return _MarkedForDelete;
    }

    /**
     * @brief Gets the account number
     * 
     * @return string The unique account number identifier
     */
    string AccountNumber()
    {
        return _AccountNumber;
    }

    void SetPinCode(string PinCode)
    {
        _PinCode = PinCode;
    }

    string GetPinCode()
    {
        return _PinCode;
    }
    __declspec(property(get = GetPinCode, put = SetPinCode)) string PinCode;

    void SetAccountBalance(float AccountBalance)
    {
        _AccountBalance = AccountBalance;
    }

    float GetAccountBalance()
    {
        return _AccountBalance;
    }
    __declspec(property(get = GetAccountBalance, put = SetAccountBalance)) float AccountBalance;


    static clsBankClient Find(string AccountNumber)
    {


        fstream MyFile;
        MyFile.open("Clients.txt", ios::in);//read Mode

        if (MyFile.is_open())
        {
            string Line;
            while (getline(MyFile, Line))
            {
                clsBankClient Client = _ConvertLinetoClientObject(Line);
                if (Client.AccountNumber() == AccountNumber)
                {
                    MyFile.close();
                    return Client;
                }

            }

            MyFile.close();

        }

        return _GetEmptyClientObject();
    }

    static clsBankClient Find(string AccountNumber, string PinCode)
    {



        fstream MyFile;
        MyFile.open("Clients.txt", ios::in);//read Mode

        if (MyFile.is_open())
        {
            string Line;
            while (getline(MyFile, Line))
            {
                clsBankClient Client = _ConvertLinetoClientObject(Line);
                if (Client.AccountNumber() == AccountNumber && Client.PinCode == PinCode)
                {
                    MyFile.close();
                    return Client;
                }

            }

            MyFile.close();

        }
        return _GetEmptyClientObject();
    }

    enum enSaveResults { svFaildEmptyObject = 0, svSucceeded = 1, svFaildAccountNumberExists = 2 };
    enSaveResults Save()
    {

        switch (_Mode)
        {
        case enMode::EmptyMode:
        {
            if (IsEmpty())
            {

                return enSaveResults::svFaildEmptyObject;

            }

        }

        case enMode::UpdateMode:
        {


            _Update();

            return enSaveResults::svSucceeded;

            break;
        }

        case enMode::AddNewMode:
        {
            //This will add new record to file or database
            if (clsBankClient::IsClientExist(_AccountNumber))
            {
                return enSaveResults::svFaildAccountNumberExists;
            }
            else
            {
                _AddNew();

                //We need to set the mode to update after add new
                _Mode = enMode::UpdateMode;
                return enSaveResults::svSucceeded;
            }

            break;
        }
        }



    }

    static bool IsClientExist(string AccountNumber)
    {

        clsBankClient Client1 = clsBankClient::Find(AccountNumber);
        return (!Client1.IsEmpty());
    }

    bool Delete()
    {
        vector <clsBankClient> _vClients;
        _vClients = _LoadClientsDataFromFile();

        for (clsBankClient& C : _vClients)
        {
            if (C.AccountNumber() == _AccountNumber)
            {
                C._MarkedForDelete = true;
                break;
            }

        }

        _SaveCleintsDataToFile(_vClients);

        *this = _GetEmptyClientObject();

        return true;

    }

    static clsBankClient GetAddNewClientObject(string AccountNumber)
    {
        return clsBankClient(enMode::AddNewMode, "", "", "", "", AccountNumber, "", 0);
    }

    static vector <clsBankClient> GetClientsList()
    {
        return _LoadClientsDataFromFile();
    }


    /**
     * @brief Deposits money into the client's account
     * 
     * Adds the specified amount to the account balance and saves
     * the changes to the data file.
     * 
     * @param Amount The amount to deposit (must be positive)
     * @note The amount is added directly without validation
     */
    void Deposit(double Amount)
    {
        _AccountBalance += Amount;
        Save();
    }

    /**
     * @brief Withdraws money from the client's account
     * 
     * Attempts to withdraw the specified amount from the account balance.
     * Only allows withdrawal if sufficient funds are available.
     * 
     * @param Amount The amount to withdraw (must be positive)
     * @return true if withdrawal was successful, false if insufficient funds
     */
    bool Withdraw(double Amount)
    {
        if (Amount > _AccountBalance)
        {
            return false; // Insufficient funds
        }
        else
        {
            _AccountBalance -= Amount;
            Save();
            return true;
        }
    }

    static double GetTotalBalances()
    {
        vector <clsBankClient> vClients = clsBankClient::GetClientsList();

        double TotalBalances = 0;

        for (clsBankClient Client : vClients)
        {

            TotalBalances += Client.AccountBalance;
        }

        return TotalBalances;
    }

};