FileManager.cpp

#include "../include/FileManager.h"
#include "../include/PrintedBook.h"
#include "../include/DigitalBook.h"
#include "../include/Admin.h"
#include "../include/Librarian.h"
#include "../include/Member.h"
#include "../include/Utils.h"

FileManager::FileManager(std::string booksPath, std::string usersPath,
                         std::string txPath, std::string finesPath, std::string logPath)
    : booksFilePath(booksPath), usersFilePath(usersPath),
      transactionsFilePath(txPath), finesFilePath(finesPath), logFilePath(logPath) {}

bool FileManager::loadAllData(Database& db) {
    bool b1 = loadUsers(db);
    bool b2 = loadBooks(db);
    bool b3 = loadTransactions(db);
    bool b4 = loadFines(db);
    logEvent("Loaded system data from persistent disk storage.");
    return b1 && b2 && b3 && b4;
}

bool FileManager::saveAllData(const Database& db) {
    bool b1 = saveUsers(db);
    bool b2 = saveBooks(db);
    bool b3 = saveTransactions(db);
    bool b4 = saveFines(db);
    logEvent("Saved all database records to persistent storage.");
    return b1 && b2 && b3 && b4;
}

bool FileManager::loadBooks(Database& db) {
    std::ifstream file(booksFilePath);
    if (!file.is_open()) return false;

    std::string line;
    while (std::getline(file, line)) {
        if (line.empty() || line[0] == '#') continue;
        auto tokens = Utils::split(line, ',');
        if (tokens.size() < 11) continue;

        std::string type = tokens[0];
        std::string isbn = tokens[1];
        std::string title = tokens[2];
        std::string author = tokens[3];
        std::string category = tokens[4];
        int year = std::stoi(tokens[5]);
        int totalCopies = std::stoi(tokens[6]);
        int availCopies = std::stoi(tokens[7]);

        if (type == "Printed") {
            std::string shelf = tokens[8];
            int pages = std::stoi(tokens[9]);
            std::string cond = tokens[10];
            auto book = std::make_shared<PrintedBook>(isbn, title, author, category, year, totalCopies, shelf, pages, cond);
            book->setAvailableCopies(availCopies);
            db.addBook(book);
        } else if (type == "Digital") {
            double sizeMB = std::stod(tokens[8]);
            std::string format = tokens[9];
            std::string url = tokens[10];
            auto book = std::make_shared<DigitalBook>(isbn, title, author, category, year, totalCopies, sizeMB, format, url);
            book->setAvailableCopies(availCopies);
            db.addBook(book);
        }
    }
    file.close();
    return true;
}

bool FileManager::saveBooks(const Database& db) {
    std::ofstream file(booksFilePath);
    if (!file.is_open()) return false;

    file << "#Type,ISBN,Title,Author,Category,Year,TotalCopies,AvailableCopies,Extra1,Extra2,Extra3\n";
    for (const auto& pair : db.books) {
        const auto& b = pair.second;
        if (b->getBookType() == "Printed") {
            auto pb = std::dynamic_pointer_cast<PrintedBook>(b);
            file << "Printed," << pb->getIsbn() << "," << pb->getTitle() << "," << pb->getAuthor() << ","
                 << pb->getCategory() << "," << pb->getPublicationYear() << "," << pb->getTotalCopies() << ","
                 << pb->getAvailableCopies() << "," << pb->getShelfLocation() << "," << pb->getPageCount() << ","
                 << pb->getCondition() << "\n";
        } else if (b->getBookType() == "Digital") {
            auto dbk = std::dynamic_pointer_cast<DigitalBook>(b);
            file << "Digital," << dbk->getIsbn() << "," << dbk->getTitle() << "," << dbk->getAuthor() << ","
                 << dbk->getCategory() << "," << dbk->getPublicationYear() << "," << dbk->getTotalCopies() << ","
                 << dbk->getAvailableCopies() << "," << dbk->getFileSizeMB() << "," << dbk->getFileFormat() << ","
                 << dbk->getDownloadUrl() << "\n";
        }
    }
    file.close();
    return true;
}

bool FileManager::loadUsers(Database& db) {
    std::ifstream file(usersFilePath);
    if (!file.is_open()) return false;

    std::string line;
    while (std::getline(file, line)) {
        if (line.empty() || line[0] == '#') continue;
        auto tokens = Utils::split(line, ',');
        if (tokens.size() < 6) continue;

        std::string roleStr = tokens[0];
        std::string uId = tokens[1];
        std::string passHash = tokens[2];
        std::string name = tokens[3];
        std::string email = tokens[4];
        std::string phone = tokens[5];

        if (roleStr == "Admin") {
            std::string level = (tokens.size() > 6) ? tokens[6] : "SystemAdmin";
            auto admin = std::make_shared<Admin>(uId, "", name, email, phone, level);
            admin->setPassword(passHash); // Keep original hash
            admin->setPassword(passHash); // Overwrite hash directly
            // Direct set password hash override:
            // Since User has passwordHash protected, User constructor hashes raw password, so we set raw pass hash directly:
            struct UserAccess : public User {
                using User::passwordHash;
            };
            std::static_pointer_cast<UserAccess>(admin)->passwordHash = passHash;
            db.addUser(admin);
        } else if (roleStr == "Librarian") {
            std::string empId = (tokens.size() > 6) ? tokens[6] : "EMP-" + uId;
            std::string shift = (tokens.size() > 7) ? tokens[7] : "Day";
            auto lib = std::make_shared<Librarian>(uId, "", name, email, phone, empId, shift);
            struct UserAccess : public User { using User::passwordHash; };
            std::static_pointer_cast<UserAccess>(lib)->passwordHash = passHash;
            db.addUser(lib);
        } else if (roleStr == "Member") {
            int limit = (tokens.size() > 6) ? std::stoi(tokens[6]) : 5;
            double fines = (tokens.size() > 7) ? std::stod(tokens[7]) : 0.0;
            auto mem = std::make_shared<Member>(uId, "", name, email, phone, limit);
            mem->setUnpaidFines(fines);
            struct UserAccess : public User { using User::passwordHash; };
            std::static_pointer_cast<UserAccess>(mem)->passwordHash = passHash;
            db.addUser(mem);
        }
    }
    file.close();
    return true;
}

bool FileManager::saveUsers(const Database& db) {
    std::ofstream file(usersFilePath);
    if (!file.is_open()) return false;

    file << "#Role,UserId,PasswordHash,Name,Email,Phone,Extra1,Extra2\n";
    for (const auto& pair : db.users) {
        const auto& u = pair.second;
        if (u->getRole() == UserRole::ADMIN) {
            auto adm = std::dynamic_pointer_cast<Admin>(u);
            file << "Admin," << adm->getUserId() << "," << adm->getPasswordHash() << "," << adm->getName() << ","
                 << adm->getEmail() << "," << adm->getPhone() << "," << adm->getAdminLevel() << "\n";
        } else if (u->getRole() == UserRole::LIBRARIAN) {
            auto lib = std::dynamic_pointer_cast<Librarian>(u);
            file << "Librarian," << lib->getUserId() << "," << lib->getPasswordHash() << "," << lib->getName() << ","
                 << lib->getEmail() << "," << lib->getPhone() << "," << lib->getEmployeeId() << "," << lib->getShiftHours() << "\n";
        } else if (u->getRole() == UserRole::MEMBER) {
            auto mem = std::dynamic_pointer_cast<Member>(u);
            file << "Member," << mem->getUserId() << "," << mem->getPasswordHash() << "," << mem->getName() << ","
                 << mem->getEmail() << "," << mem->getPhone() << "," << mem->getMaxBorrowLimit() << "," << mem->getUnpaidFines() << "\n";
        }
    }
    file.close();
    return true;
}

bool FileManager::loadTransactions(Database& db) {
    std::ifstream file(transactionsFilePath);
    if (!file.is_open()) return false;

    std::string line;
    while (std::getline(file, line)) {
        if (line.empty() || line[0] == '#') continue;
        auto tokens = Utils::split(line, ',');
        if (tokens.size() < 7) continue;

        Transaction tx(tokens[0], tokens[1], tokens[2], tokens[3], tokens[4], tokens[5], tokens[6]);
        db.addTransaction(tx);

        // Update member borrowed books list if status is ISSUED or RENEWED
        if (tokens[6] == "ISSUED" || tokens[6] == "RENEWED") {
            auto u = db.getUser(tokens[1]);
            if (u && u->getRole() == UserRole::MEMBER) {
                auto mem = std::dynamic_pointer_cast<Member>(u);
                if (mem) mem->recordBorrow(tokens[2]);
            }
        }
    }
    file.close();
    return true;
}

bool FileManager::saveTransactions(const Database& db) {
    std::ofstream file(transactionsFilePath);
    if (!file.is_open()) return false;

    file << "#TransactionId,MemberId,ISBN,IssueDate,DueDate,ReturnDate,Status\n";
    for (const auto& tx : db.transactions) {
        file << tx.getTransactionId() << "," << tx.getMemberId() << "," << tx.getIsbn() << ","
             << tx.getIssueDate() << "," << tx.getDueDate() << "," << tx.getReturnDate() << ","
             << tx.getStatus() << "\n";
    }
    file.close();
    return true;
}

bool FileManager::loadFines(Database& db) {
    std::ifstream file(finesFilePath);
    if (!file.is_open()) return false;

    std::string line;
    while (std::getline(file, line)) {
        if (line.empty() || line[0] == '#') continue;
        auto tokens = Utils::split(line, ',');
        if (tokens.size() < 7) continue;

        Fine fine(tokens[0], tokens[1], tokens[2], std::stod(tokens[3]), tokens[4], (tokens[5] == "1" || tokens[5] == "true"), tokens[6]);
        db.addFine(fine);
    }
    file.close();
    return true;
}

bool FileManager::saveFines(const Database& db) {
    std::ofstream file(finesFilePath);
    if (!file.is_open()) return false;

    file << "#FineId,MemberId,TransactionId,Amount,Reason,IsPaid,DateIssued\n";
    for (const auto& f : db.fines) {
        file << f.getFineId() << "," << f.getMemberId() << "," << f.getTransactionId() << ","
             << f.getAmount() << "," << f.getReason() << "," << (f.getIsPaid() ? "1" : "0") << ","
             << f.getDateIssued() << "\n";
    }
    file.close();
    return true;
}

void FileManager::logEvent(const std::string& eventMessage) {
    std::ofstream file(logFilePath, std::ios::app);
    if (file.is_open()) {
        file << "[" << Utils::getCurrentDateStr() << "] " << eventMessage << "\n";
        file.close();
    }
}