Library.cpp

#include "../include/Library.h"
#include "../include/PrintedBook.h"
#include "../include/DigitalBook.h"
#include "../include/Admin.h"
#include "../include/Librarian.h"
#include "../include/Member.h"
#include <iostream>
#include <iomanip>

Library::Library(std::string name)
    : systemName("LibraryX - Enterprise Management System"), fileManager("data/books.csv", "data/users.csv", "data/transactions.csv", "data/fines.csv", "data/system.log") {}

Library::~Library() {
    saveAndExit();
}

void Library::startSystem() {
    fileManager.loadAllData(db);

    // Seed default users if database is empty
    if (db.getAllUsers().empty()) {
        Utils::printInfo("Seeding initial LibraryX demonstration users...");
        auto admin = std::make_shared<Admin>("admin", "adminX123", "System Administrator", "admin@libraryx.org", "+1-555-0100", "SuperAdmin");
        auto lib = std::make_shared<Librarian>("librarian", "libX123", "Sarah Jenkins", "sarah@libraryx.org", "+1-555-0101", "EMP-101", "Morning");
        auto mem = std::make_shared<Member>("member", "memX123", "Alex Johnson", "alex@example.com", "+1-555-0102", 5);

        db.addUser(admin);
        db.addUser(lib);
        db.addUser(mem);

        // Seed default books if database is empty
        auto b1 = std::make_shared<PrintedBook>("978-0134494166", "Clean Code: A Handbook of Agile Software Craftsmanship", "Robert C. Martin", "Computer Science", 2008, 3, "Shelf A-12", 464, "New");
        auto b2 = std::make_shared<PrintedBook>("978-0201633610", "Design Patterns: Elements of Reusable Object-Oriented Software", "Erich Gamma et al.", "Computer Science", 1994, 2, "Shelf A-14", 395, "Good");
        auto b3 = std::make_shared<DigitalBook>("978-0131103627", "The C Programming Language (2nd Edition)", "Brian W. Kernighan", "Computer Science", 1988, 100, 4.2, "PDF", "http://digital.library.org/dl/c_prog.pdf");
        auto b4 = std::make_shared<PrintedBook>("978-0596007126", "Head First Design Patterns", "Eric Freeman", "Computer Science", 2004, 4, "Shelf B-03", 678, "Good");

        db.addBook(b1);
        db.addBook(b2);
        db.addBook(b3);
        db.addBook(b4);

        fileManager.saveAllData(db);
    }
}

void Library::saveAndExit() {
    fileManager.saveAllData(db);
}

bool Library::loginUser(const std::string& userId, const std::string& password) {
    try {
        auto user = auth.login(userId, password, db);
        fileManager.logEvent("User logged in successfully: " + userId + " (" + user->getRoleStr() + ")");
        return true;
    } catch (const AuthException& ex) {
        Utils::printError(ex.what());
        fileManager.logEvent("Failed login attempt for user: " + userId);
        return false;
    }
}

void Library::logoutUser() {
    if (auth.isLoggedIn()) {
        fileManager.logEvent("User logged out: " + auth.getCurrentUser()->getUserId());
        auth.logout();
        Utils::printSuccess("Successfully logged out.");
    }
}

std::shared_ptr<User> Library::getActiveUser() const {
    return auth.getCurrentUser();
}

Authentication& Library::getAuth() {
    return auth;
}

Database& Library::getDatabase() {
    return db;
}

bool Library::addNewBook(std::shared_ptr<Book> book) {
    if (!auth.isStaff()) {
        Utils::printError("Permission denied! Only Admins and Librarians can add books.");
        return false;
    }
    if (db.addBook(book)) {
        fileManager.logEvent("Added new book: " + book->getTitle() + " (ISBN: " + book->getIsbn() + ")");
        fileManager.saveBooks(db);
        Utils::printSuccess("Book successfully added to catalogue!");
        return true;
    }
    Utils::printError("Failed to add book. ISBN already exists!");
    return false;
}

bool Library::editBook(std::shared_ptr<Book> book) {
    if (!auth.isStaff()) {
        Utils::printError("Permission denied! Only staff can edit books.");
        return false;
    }
    if (db.updateBook(book)) {
        fileManager.saveBooks(db);
        Utils::printSuccess("Book updated successfully!");
        return true;
    }
    Utils::printError("Book update failed!");
    return false;
}

bool Library::deleteBook(const std::string& isbn) {
    if (!auth.isStaff()) {
        Utils::printError("Permission denied! Only staff can delete books.");
        return false;
    }
    if (db.removeBook(isbn)) {
        fileManager.logEvent("Deleted book ISBN: " + isbn);
        fileManager.saveBooks(db);
        Utils::printSuccess("Book deleted from catalogue.");
        return true;
    }
    Utils::printError("Book not found!");
    return false;
}

void Library::listAllBooks() const {
    Utils::printHeader("LIBRARY CATALOGUE (" + std::to_string(Book::getTotalBooksCount()) + " Total Titles)");
    auto books = db.getAllBooks();
    if (books.empty()) {
        Utils::printInfo("Catalogue is currently empty.");
        return;
    }
    for (const auto& b : books) {
        b->displayBookInfo();
    }
    Utils::drawLine('=', 65);
}

void Library::searchBooksInteractive() const {
    std::string query = Utils::getLineInput("Enter Search Query (Title / Author / Category / ISBN): ");
    auto results = searchEngine.searchByKeyword(db.getAllBooks(), query);

    Utils::printHeader("SEARCH RESULTS (" + std::to_string(results.size()) + " Found)");
    if (results.empty()) {
        Utils::printInfo("No matching books found.");
        return;
    }

    for (const auto& b : results) {
        b->displayBookInfo();
    }
    Utils::drawLine('=', 65);
}

std::vector<std::shared_ptr<Book>> Library::searchBooks(const std::string& keyword) const {
    return searchEngine.searchByKeyword(db.getAllBooks(), keyword);
}

bool Library::registerMember(const std::string& userId, const std::string& password,
                             const std::string& name, const std::string& email, const std::string& phone) {
    auto member = std::make_shared<Member>(userId, password, name, email, phone);
    if (db.addUser(member)) {
        fileManager.saveUsers(db);
        fileManager.logEvent("Registered new member: " + userId);
        Utils::printSuccess("Member registered successfully!");
        return true;
    }
    Utils::printError("User ID '" + userId + "' already exists!");
    return false;
}

bool Library::registerStaff(const std::string& userId, const std::string& password, UserRole role,
                            const std::string& name, const std::string& email, const std::string& phone) {
    if (!auth.isAdmin()) {
        Utils::printError("Permission denied! Only Super Admin can register staff members.");
        return false;
    }
    std::shared_ptr<User> staff;
    if (role == UserRole::ADMIN) {
        staff = std::make_shared<Admin>(userId, password, name, email, phone);
    } else {
        staff = std::make_shared<Librarian>(userId, password, name, email, phone);
    }

    if (db.addUser(staff)) {
        fileManager.saveUsers(db);
        fileManager.logEvent("Registered new staff user: " + userId);
        Utils::printSuccess("Staff user registered successfully!");
        return true;
    }
    Utils::printError("User ID already exists!");
    return false;
}

void Library::listAllUsers() const {
    if (!auth.isStaff()) {
        Utils::printError("Permission denied!");
        return;
    }
    Utils::printHeader("REGISTERED USERS DIRECTORY");
    auto users = db.getAllUsers();
    for (const auto& u : users) {
        u->displayDetails();
    }
    Utils::drawLine('=', 65);
}

bool Library::issueBook(const std::string& memberId, const std::string& isbn) {
    if (!auth.isStaff()) {
        Utils::printError("Permission denied! Only staff can issue books.");
        return false;
    }

    auto user = db.getUser(memberId);
    if (!user || user->getRole() != UserRole::MEMBER) {
        Utils::printError("Member ID '" + memberId + "' not found!");
        return false;
    }

    auto member = std::dynamic_pointer_cast<Member>(user);
    if (!member->canBorrow()) {
        if (member->getUnpaidFines() > 0) {
            Utils::printError("Cannot issue book! Member has pending unpaid fines: $" + std::to_string(member->getUnpaidFines()));
        } else if (!member->getIsActive()) {
            Utils::printError("Cannot issue book! Member account is suspended.");
        } else {
            Utils::printError("Cannot issue book! Member has reached maximum borrowing limit of " + std::to_string(member->getMaxBorrowLimit()) + " books.");
        }
        return false;
    }

    auto book = db.getBook(isbn);
    if (!book) {
        Utils::printError("Book ISBN '" + isbn + "' not found!");
        return false;
    }

    if (!book->getIsAvailable()) {
        Utils::printError("Book '" + book->getTitle() + "' is currently out of stock!");
        std::string choice = Utils::getLineInput("Would member like to reserve this book? (y/n): ");
        if (Utils::toLower(choice) == "y") {
            reserveBook(memberId, isbn);
        }
        return false;
    }

    // Execute Borrow Transaction
    book->borrowCopy();
    std::string today = Utils::getCurrentDateStr();
    std::string dueDate = Utils::addDaysToDate(today, 14); // 14-day borrowing period

    Transaction tx("", memberId, isbn, today, dueDate, "-", "ISSUED");
    db.addTransaction(tx);
    member->recordBorrow(isbn);

    fileManager.saveAllData(db);
    fileManager.logEvent("Book issued: " + isbn + " to member " + memberId);
    Utils::printSuccess("Book successfully issued to " + member->getName() + "! Due date: " + dueDate);
    return true;
}

bool Library::returnBook(const std::string& memberId, const std::string& isbn, bool isDamaged, bool isLost) {
    if (!auth.isStaff()) {
        Utils::printError("Permission denied! Only staff can process returns.");
        return false;
    }

    Transaction* tx = db.getActiveTransaction(memberId, isbn);
    if (!tx) {
        Utils::printError("No active borrow transaction found for Member " + memberId + " and ISBN " + isbn);
        return false;
    }

    auto user = db.getUser(memberId);
    auto member = std::dynamic_pointer_cast<Member>(user);
    auto book = db.getBook(isbn);

    std::string today = Utils::getCurrentDateStr();
    tx->setReturnDate(today);
    tx->setStatus("RETURNED");

    if (member) member->recordReturn(isbn);

    // Overdue Days & Fines Calculation
    int overdueDays = Utils::calculateDaysBetween(tx->getDueDate(), today);
    double totalFine = 0.0;

    if (overdueDays > 0) {
        double overdueFine = Fine::calculateOverdueFine(overdueDays);
        totalFine += overdueFine;
        Utils::printInfo("Overdue by " + std::to_string(overdueDays) + " days. Overdue fine: $" + std::to_string(overdueFine));
    }

    if (isLost) {
        double lostFine = Fine::calculateLostBookFine(50.0); // Default replacement base
        totalFine += lostFine;
        Utils::printError("Lost Book Penalty applied: $" + std::to_string(lostFine));
    } else if (isDamaged) {
        double damageFine = Fine::calculateDamageFine(50.0);
        totalFine += damageFine;
        Utils::printError("Damaged Book Penalty applied: $" + std::to_string(damageFine));
    } else {
        book->returnCopy();
    }

    if (totalFine > 0.0) {
        std::string fineId = "FINE-" + std::to_string(rand() % 90000 + 10000);
        Fine fine(fineId, memberId, tx->getTransactionId(), totalFine, isLost ? "LOST_BOOK" : (isDamaged ? "DAMAGED_BOOK" : "OVERDUE"), false, today);
        db.addFine(fine);
        Utils::printError("Fine of $" + std::to_string(totalFine) + " generated for Member ID: " + memberId);
    }

    // Process pending reservation queue
    if (db.hasReservations(isbn) && !isLost) {
        std::string nextMemberId = db.popNextReservation(isbn);
        Notification notif("NOTIF-" + std::to_string(rand() % 9000), nextMemberId, "The reserved book '" + book->getTitle() + "' is now available!", today);
        db.addNotification(notif);
        Utils::printInfo("Notification sent to next reserving member: " + nextMemberId);
    }

    fileManager.saveAllData(db);
    fileManager.logEvent("Returned book: " + isbn + " from member " + memberId);
    Utils::printSuccess("Book return processed successfully!");
    return true;
}

bool Library::renewBook(const std::string& memberId, const std::string& isbn) {
    Transaction* tx = db.getActiveTransaction(memberId, isbn);
    if (!tx) {
        Utils::printError("No active transaction found for renewal.");
        return false;
    }

    if (db.hasReservations(isbn)) {
        Utils::printError("Cannot renew book! This item has pending reservations from other members.");
        return false;
    }

    std::string newDueDate = Utils::addDaysToDate(tx->getDueDate(), 14);
    tx->setDueDate(newDueDate);
    tx->setStatus("RENEWED");

    fileManager.saveTransactions(db);
    fileManager.logEvent("Renewed book: " + isbn + " for member " + memberId);
    Utils::printSuccess("Book renewal successful! New due date: " + newDueDate);
    return true;
}

bool Library::reserveBook(const std::string& memberId, const std::string& isbn) {
    auto book = db.getBook(isbn);
    if (!book) {
        Utils::printError("Book not found!");
        return false;
    }

    db.reserveBook(isbn, memberId);
    fileManager.logEvent("Member " + memberId + " reserved book ISBN: " + isbn);
    Utils::printSuccess("Reservation placed! You will be notified when a copy becomes available.");
    return true;
}

void Library::viewMemberFines(const std::string& memberId) const {
    Utils::printHeader("FINE RECORDS FOR MEMBER: " + memberId);
    auto fines = db.getMemberFines(memberId);
    if (fines.empty()) {
        Utils::printInfo("No fine records found.");
        return;
    }

    for (const auto& f : fines) {
        std::cout << "[Fine ID]: " << f.getFineId()
                  << " | Transaction: " << f.getTransactionId()
                  << " | Reason: " << f.getReason()
                  << " | Amount: $" << f.getAmount()
                  << " | Status: " << (f.getIsPaid() ? "PAID" : "PENDING") << "\n";
    }
    Utils::drawLine('=', 65);
}

bool Library::processFinePayment(const std::string& fineId) {
    if (db.payFine(fineId)) {
        fileManager.saveAllData(db);
        fileManager.logEvent("Fine paid: " + fineId);
        Utils::printSuccess("Fine payment processed successfully!");
        return true;
    }
    Utils::printError("Fine ID not found or already paid!");
    return false;
}

void Library::runReportsMenu() const {
    if (!auth.isStaff()) {
        Utils::printError("Permission denied!");
        return;
    }
    Report::generateInventoryReport(db.getAllBooks());
    Report::generateMostBorrowedReport(db.getAllTransactions(), db.getAllBooks());
    Report::generateActiveMembersReport(db.getAllUsers(), db.getAllTransactions());
    Report::generateRevenueReport(db.getAllFines());
}