UserManager.cpp

//
// Created by matin on 1/2/26.
//

#include "UserManager.h"
#include <sstream>
#include <iostream>

UserManager::UserManager(const string& filename) : nextUserId(1), dataFile(filename) {
    loadFromFile();
}

UserManager::~UserManager() {
    clear();
}


void UserManager::updateIdCounter() {
    nextUserId = 1;
    for (const User* user : users) {
        if (user->getUserId() >= nextUserId) {
            nextUserId = user->getUserId() + 1;
        }
    }
}

void UserManager::loadFromFile() {
    clear();
    ifstream file(dataFile);
    if (!file.is_open()) {
        return;
    }
    string line;
    while (getline(file, line)) {
        if (line.empty()) continue;
        try {
            User* user = User::deserialize(line);
            if (user) {
                users.push_back(user);
                usernameMap[user->getUsername()] = user;
                userIdMap[user->getUserId()] = user;
            }
        } catch (...) {
            // Skip
        }
    }
    file.close();
    updateIdCounter();
}

void UserManager::saveToFile() const {
    ofstream file(dataFile);
    if (!file.is_open()) {
        throw FileIOException("Cannot open file for writing: " + dataFile);
    }
    for (const User* user : users) {
        file << user->serialize() << endl;
    }
    file.close();
}

LocalUser* UserManager::registerUser(const string& username, const string& fullName,const string& birthdate, const string& password) {
    User::validateUsername(username);
    User::validateFullName(fullName);
    User::validatePassword(password);
    User::validateBirthdate(birthdate);
    if (usernameExists(username)) {
        throw UsernameTakenException("Username '" + username + "' is already taken");
    }
    Date birth = Date::fromString(birthdate);
    Date joinDate;
    LocalUser* newUser = new LocalUser(nextUserId++, username, fullName, password, birth, joinDate);
    users.push_back(newUser);
    usernameMap[username] = newUser;
    userIdMap[newUser->getUserId()] = newUser;
    saveToFile();
    return newUser;
}

LocalUser* UserManager::login(const string& username, const string& password) {
    auto it = usernameMap.find(username);
    if (it == usernameMap.end()) {
        throw InvalidUserException("User '" + username + "' does not exist");
    }
    User* user = it->second;
    if (user->getPassword() != password) {
        throw WrongPasswordException("Incorrect password");
    }
    return dynamic_cast<LocalUser*>(user);
}

bool UserManager::usernameExists(const string& username) const {
    return usernameMap.find(username) != usernameMap.end();
}

bool UserManager::userIdExists(int userId) const {
    return userIdMap.find(userId) != userIdMap.end();
}

User* UserManager::findByUsername(const string& username) const {
    auto it = usernameMap.find(username);
    if (it != usernameMap.end()) {
        return it->second;
    }
    return nullptr;
}

User* UserManager::findById(int userId) const {
    auto it = userIdMap.find(userId);
    if (it != userIdMap.end()) {
        return it->second;
    }
    return nullptr;
}

int UserManager::getUserIdByUsername(const string& username) const {
    User* user = findByUsername(username);
    if (user) {
        return user->getUserId();
    }
    throw InvalidUserException("User '" + username + "' does not exist");
}

string UserManager::getUsernameById(int userId) const {
    User* user = findById(userId);
    if (user) {
        return user->getUsername();
    }
    return "Unknown";
}

vector<User*> UserManager::searchByName(const string& name) const {
    vector<User*> results;
    string lowerName = name;
    transform(lowerName.begin(), lowerName.end(), lowerName.begin(), ::tolower);

    for (User* user : users) {
        string fullName = user->getFullName();
        transform(fullName.begin(), fullName.end(), fullName.begin(), ::tolower);
        if (fullName.find(lowerName) != string::npos) {
            results.push_back(user);
        }
    }
    return results;
}

vector<User*> UserManager::searchByUsername(const string& username) const {
    vector<User*> results;
    string lowerSearch = username;
    transform(lowerSearch.begin(), lowerSearch.end(), lowerSearch.begin(), ::tolower);

    for (User* user : users) {
        string uname = user->getUsername();
        transform(uname.begin(), uname.end(), uname.begin(), ::tolower);
        if (uname.find(lowerSearch) != string::npos) {
            results.push_back(user);
        }
    }
    return results;
}

vector<User*> UserManager::sortByName() {
    vector<User*> &sorted = users;
    sort(sorted.begin(), sorted.end(), [](const User* a, const User* b) {return a->getFullName() < b->getFullName();});
    return sorted;
}

vector<User*> UserManager::sortByJoinDate() {
    vector<User*> &sorted = users;
    sort(sorted.begin(), sorted.end(), [](const User* a, const User* b) {return a->getJoinDate() < b->getJoinDate();});
    return sorted;
}

vector<User*> UserManager::sortById() {
    vector<User*> &sorted = users;
    sort(sorted.begin(), sorted.end(), [](const User* a, const User* b) {
        return a->getUserId() < b->getUserId();
    });
    return sorted;
}

void UserManager::clear() {
    for (User* user : users) {
        delete user;
    }
    users.clear();
    usernameMap.clear();
    userIdMap.clear();
}