Statistics.cpp

#define _CRT_SECURE_NO_WARNINGS
#include "Statistics.h"
#include <algorithm>
#include <ctime>

using namespace std;

void Statistics::recordTransaction(const std::string& sender, const std::string& receiver, double amount) {
    // Update transaction counts
    userTransactionCount[sender]++;
    userTransactionCount[receiver]++;

    // Update sorted transaction counts
    for (const auto& user : { sender, receiver }) {
        int count = userTransactionCount[user];

        // Remove from old count if exists
        for (auto& [c, users] : transactionCountToUsers) {
            users.erase(user);
            if (users.empty()) {
                transactionCountToUsers.erase(c);
            }
        }

        // Add to new count
        transactionCountToUsers[count].insert(user);
    }

    // Record large transactions
    std::string transactionInfo = sender + " -> " + receiver;
    topTransactions.push({ amount, transactionInfo });

    // Record user interaction
    userInteractions[sender][receiver]++;
    userInteractions[receiver][sender]++;

    // Record hourly activity
    std::time_t now = std::time(nullptr);
    struct tm timeinfo;
    localtime_s(&timeinfo, &now);
    hourlyTransactionCount[timeinfo.tm_hour]++;
}

void Statistics::recordLogin(const std::string& username) {
    std::time_t now = std::time(nullptr);

    // Add to login history
    loginHistory.emplace_back(now, username);

    // Update user's login times
    auto& userQueue = userLoginTimes[username];
    userQueue.push(now);

    // Keep only last 10 logins
    if (userQueue.size() > 10) {
        userQueue.pop();
    }
}

void Statistics::recordFailedOperation(const std::string& username, const std::string& error) {
    failedOperations[username].push_back(error);
}

std::vector<std::string> Statistics::getMostActiveUsers(int count) const {
    std::vector<std::string> result;

    // Iterate through transaction counts in reverse (highest first)
    for (auto it = transactionCountToUsers.rbegin();
        it != transactionCountToUsers.rend() && result.size() < count;
        ++it) {
        for (const auto& user : it->second) {
            if (result.size() < count) {
                result.push_back(user);
            }
            else {
                break;
            }
        }
    }

    return result;
}

std::vector<std::pair<double, std::string>> Statistics::getLargestTransactions(int count) const {
    std::vector<std::pair<double, std::string>> result;
    auto tempQueue = topTransactions;

    while (!tempQueue.empty() && result.size() < count) {
        result.push_back(tempQueue.top());
        tempQueue.pop();
    }

    return result;
}

std::vector<std::pair<std::string, std::string>> Statistics::getMostFrequentInteractions() const {
    std::vector<std::pair<std::string, std::string>> result;
    std::vector<std::tuple<int, std::string, std::string>> interactions;

    // Collect all interactions
    for (const auto& [user1, userMap] : userInteractions) {
        for (const auto& [user2, count] : userMap) {
            if (user1 < user2) { // Avoid duplicates
                interactions.emplace_back(count, user1, user2);
            }
        }
    }

    // Sort by count
    std::sort(interactions.rbegin(), interactions.rend());

    // Take top 5 interactions
    for (const auto& [count, user1, user2] : interactions) {
        if (result.size() >= 5) break;
        result.emplace_back(user1, user2);
    }

    return result;
}

int Statistics::getPeakActivityHour() const {
    if (hourlyTransactionCount.empty()) return -1;

    return std::max_element(
        hourlyTransactionCount.begin(),
        hourlyTransactionCount.end(),
        [](const auto& p1, const auto& p2) {
            return p1.second < p2.second;
        }
    )->first;
}

std::vector<std::string> Statistics::getUserErrors(const std::string& username) const {
    auto it = failedOperations.find(username);
    if (it != failedOperations.end()) {
        return it->second;
    }
    return {};
}

void Statistics::clearOldHistory(std::time_t before) {
    // Clear old login history
    loginHistory.erase(
        std::remove_if(
            loginHistory.begin(),
            loginHistory.end(),
            [before](const auto& entry) {
                return entry.first < before;
            }
        ),
        loginHistory.end()
    );

    // Clear old login times from user queues
    for (auto& [username, times] : userLoginTimes) {
        while (!times.empty() && times.front() < before) {
            times.pop();
        }
    }
}

void Statistics::pruneLoginHistory(int maxPerUser) {
    for (auto& [username, times] : userLoginTimes) {
        while (times.size() > maxPerUser) {
            times.pop();
        }
    }
}