User.cpp

#include "User.h"
#include <ctime>
#include <string>
#include <functional>
#include <sstream>
#include <iomanip>
#include <iostream>
#include "HashUtils.h"

using namespace std;

User::User(const string& username, const string& password, bool isAdmin)
    : username(username), passwordHash(HashUtils::hashPassword(password)), balance(0.0), isAdmin(isAdmin), isActive(true), failedLoginAttempts(0), isLocked(false) {
}

bool User::login(const string& inputPassword) {
    if (!isActive || isLocked) return false;
    if (passwordHash == HashUtils::hashPassword(inputPassword)) {
        failedLoginAttempts = 0;
        return true;
    }
    else {
        failedLoginAttempts++;
        if (failedLoginAttempts >= 5) {
            isLocked = true;
            notifications.push("Your account has been locked due to too many failed login attempts.");
        }
        return false;
    }
}

bool User::changePassword(const string& oldPassword, const string& newPassword) {
    if (passwordHash != HashUtils::hashPassword(oldPassword)) {
        return false;
    }
    passwordHash = HashUtils::hashPassword(newPassword);
    return true;
}

void User::unlockAccount() {
    isLocked = false;
    failedLoginAttempts = 0;
}

bool User::getIsLocked() const {
    return isLocked;
}

void User::resetFailedLoginAttempts() {
    failedLoginAttempts = 0;
}

bool User::sendMoney(double amount) {
    if (amount <= 0 || amount > balance) {
        return false;
    }
    balance -= amount;
    addTransaction("Sent money", -amount);
    return true;
}

void User::receiveMoney(double amount) {
    if (amount <= 0) {
        return;
    }
    balance += amount;
    addTransaction("Received money", amount);
}

void User::addTransaction(const string& description, double amount) {
    transactionHistory.emplace_back(description, amount);
}

string User::getUsername() const {
    return username;
}

double User::getBalance() const {
    return balance;
}

bool User::getIsAdmin() const {
    return isAdmin;
}

bool User::getIsActive() const {
    return isActive;
}

const vector<pair<string, double>>& User::getTransactionHistory() const {
    return transactionHistory;
}

void User::setBalance(double newBalance) {
    if (newBalance >= 0) {
        balance = newBalance;
    }
}

void User::setActive(bool status) {
    isActive = status;
}

void User::addTrustedUser(const string& trusted) {
    trustedUsers.insert(trusted);
}

void User::removeTrustedUser(const string& trusted) {
    trustedUsers.erase(trusted);
}

bool User::isTrustedUser(const string& user) const {
    return trustedUsers.find(user) != trustedUsers.end();
}

void User::addPendingTransaction(const string& desc, double amount) {
    pendingTransactions.emplace_back(desc, amount);
}

void User::confirmPendingTransaction() {
    if (!pendingTransactions.empty()) {
        auto& transaction = pendingTransactions.front();
        addTransaction(transaction.first, transaction.second);
        balance += transaction.second;
        pendingTransactions.pop_front();
    }
}

void User::rejectPendingTransaction() {
    if (!pendingTransactions.empty()) {
        pendingTransactions.pop_front();
    }
}

void User::pushRecentAction(const string& action, double amount) {
    recentActions.push(make_pair(action, amount));
}

bool User::undoLastAction() {
    if (recentActions.empty()) {
        return false;
    }

    auto lastAction = recentActions.top();
    recentActions.pop();

    // Reverse the last action's effect on balance
    balance -= lastAction.second;
    addTransaction("Undo: " + lastAction.first, -lastAction.second);

    return true;
}

void User::addNotification(const string& message) {
    notifications.push(message);
}

vector<string> User::getNotifications() {
    vector<string> result;
    while (!notifications.empty()) {
        result.push_back(notifications.front());
        notifications.pop();
    }
    return result;
}

const list<pair<string, double>>& User::getPendingTransactions() const {
    return pendingTransactions;
}

vector<pair<string, double>> User::getRecentActions(int count) const {
    vector<pair<string, double>> result;
    stack<pair<string, double>> temp = recentActions;

    while (!temp.empty() && count > 0) {
        result.push_back(temp.top());
        temp.pop();
        count--;
    }

    return result;
}

vector<string> User::getTrustedUsers() const {
    vector<string> result(trustedUsers.begin(), trustedUsers.end());
    return result;
}

void User::setUsername(const string& newUsername) {
    username = newUsername;
}

void User::setPasswordHash(const string& hash) {
    passwordHash = hash;
}