/*
File: Controller.cpp
Description: Implementation file containing the method definitions of the
             Controller class, including authentication, user creation,
             service purchasing, and system checks.
Author: Trenser
Date:19-May-2026
*/
#include "ComboPackage.h"
#include "Controller.h"
#include "Enums.h"
#include "InventoryItem.h"
#include "Invoice.h"
#include "JobCard.h"
#include "Service.h"
#include "ServiceBooking.h"
#include "User.h"
#include <stdexcept>

/*
Function: login
Description: Authenticates a user by delegating to the authentication management service.
Parameter: const std::string& username - user’s username
           const std::string& password - user’s password
Return type: bool - true if login successful, false otherwise
*/
bool Controller::login(const std::string& username, const std::string& password)
{
    return m_authenticationManagementService.login(username, password);
}

/*
Function: logout
Description: Logs out the currently authenticated user.
Parameter: None
Return type: void
*/
void Controller::logout()
{
    m_authenticationManagementService.logout();
}

/*
Function: changePassword
Description: Changes the password of the currently authenticated user.
Parameter: const std::string& newPassword - new password to set
Return type: void
*/
void Controller::changePassword(const std::string& newPassword)
{
    m_authenticationManagementService.changePassword(newPassword);
}

/*
Function: createCustomer
Description: Creates a new customer account with the provided details.
Parameter: const std::string& username - customer’s username
           const std::string& name - customer’s name
           const std::string& password - customer’s password
           const std::string& email - customer’s email
           const std::string& phone - customer’s phone number
Return type: void
*/

void Controller::createCustomer(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phone)
{
    m_userManagementService.createUser(username, name, password, email, phone, util::UserType::CUSTOMER);
}

/*
Function: getAuthenticatedUser
Description: Retrieves the currently authenticated user.
Parameter: None
Return type: const User* - pointer to the authenticated user
*/
const User* Controller::getAuthenticatedUser()
{
    return m_authenticationManagementService.getAuthenticatedUser();
}

/*
Function: createTechnician
Description: Creates a new technician account with provided details by
             delegating to the user management service.
Parameter: const std::string& username - technician's username
           const std::string& password - technician's password
           const std::string& email - technician's email address
           const std::string& phoneNumber - technician's phone number
Return type: void
*/
void Controller::createTechnician(const std::string& username, const std::string& name, const std::string& password, const std::string& email, const std::string& phoneNumber)
{
    m_userManagementService.createUser(username, name, password, email, phoneNumber, util::UserType::TECHNICIAN);
}

/*
Function: updateUserDetails
Description: Updates the email and phone details of the currently authenticated user.
Parameter: const std::string& email - new email address
           const std::string& phone - new phone number
Return type: void
*/
void Controller::updateUserDetails(const std::string& email, const std::string& phone)
{
    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
    if (authenticatedUser == nullptr)
    {
        throw std::runtime_error("No user currently logged in!");
    }
    m_userManagementService.updateUserDetails(authenticatedUser->getId(), email, phone);
}

/*
Function: getServices
Description: Retrieves all available services in read-only form.
Parameters:
    - None
Returns:
    - util::Map<std::string, const Service*> containing all services
*/
util::Map<std::string, const Service*> Controller::getServices()
{
    util::Map<std::string, Service*> currentServices = m_serviceManagementService.getServices();
    util::Map<std::string, const Service*> readOnlyServices;
    for (int iterator = 0; iterator < currentServices.getSize(); iterator++)
    {
        readOnlyServices.insert(currentServices.getValueAt(iterator)->getId(), currentServices.getValueAt(iterator));
    }
    return readOnlyServices;
}

/*
Function: getComboPackages
Description: Retrieves all available combo packages from the service
             management service and constructs a read-only map.
Parameter: None
Return type: util::Map<std::string, const ComboPackage*>
*/
util::Map<std::string, const ComboPackage*> Controller::getComboPackages()
{
    util::Map<std::string, ComboPackage*> currentAvailableComboPackages = m_serviceManagementService.getComboPackages();
    util::Map<std::string, const ComboPackage*> readOnlyComboPackages;
    for (int iterator = 0; iterator < currentAvailableComboPackages.getSize(); iterator++)
    {
        ComboPackage* currentComboPackage = currentAvailableComboPackages.getValueAt(iterator);
        if (currentComboPackage)
        {
            readOnlyComboPackages.insert(currentComboPackage->getId(), currentComboPackage);
        }
    }
    return readOnlyComboPackages;
}

/*
Function: purchaseService
Description: Purchases one or more services for a vehicle by delegating to the service management service.
Parameter: const util::Vector<std::string>& serviceIDs - IDs of services to purchase
           const std::string& vehicleNumber - vehicle registration number
           const std::string& vehicleBrand - brand of the vehicle
           const std::string& vehicleModel - model of the vehicle
Return type: void
*/
void Controller::purchaseService(const util::Vector<std::string>& serviceIDs, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
{
    m_serviceManagementService.purchaseService(serviceIDs, vehicleNumber, vehicleBrand, vehicleModel);
}

/*
Function: purchaseComboPackage
Description: Purchases a combo package for a vehicle by delegating to the service management service.
Parameter: const std::string& comboPackageID - ID of the combo package
           const std::string& vehicleNumber - vehicle registration number
           const std::string& vehicleBrand - brand of the vehicle
           const std::string& vehicleModel - model of the vehicle
Return type: void
*/
void Controller::purchaseComboPackage(const std::string& comboPackageID, const std::string& vehicleNumber, const std::string& vehicleBrand, const std::string& vehicleModel)
{
    m_serviceManagementService.purchaseComboPackage(comboPackageID, vehicleNumber, vehicleBrand, vehicleModel);
}

/*
Function: getInventoryItems
Description: Retrieves all inventory items from the inventory management service
             and constructs a read-only map for external use.
Parameter: None
Return type: util::Map<std::string, const InventoryItem*>
*/
util::Map<std::string, const InventoryItem*> Controller::getInventoryItems()
{
    auto inventoryItems = m_inventoryManagementService.getInventoryItems();
    util::Map<std::string, const InventoryItem*> readOnlyInventoryItems;
    int inventoryItemsMapSize = inventoryItems.getSize();
    for (int index = 0; index < inventoryItemsMapSize; index++)
    {
        readOnlyInventoryItems.insert(inventoryItems.getKeyAt(index), inventoryItems.getValueAt(index));
    }
    return readOnlyInventoryItems;
}

/*
Function: getInventoryItem
Description: Retrieves a specific inventory item by its ID from the inventory management service.
Parameter: const std::string& inventoryItemID - ID of the inventory item
Return type: const InventoryItem*
*/
const InventoryItem* Controller::getInventoryItem(const std::string& inventoryItemID)
{
    return m_inventoryManagementService.getInventoryItem(inventoryItemID);
}

/*
Function: addInventoryItem
Description: Adds a new inventory item with specified details to the inventory management service.
Parameter: const std::string& partName - name of the part
           int quantity - quantity of the part
           double price - price of the part
Return type: void
*/
void Controller::addInventoryItem(const std::string& partName, int quantity, double price)
{
    m_inventoryManagementService.addInventoryItem(partName, quantity, price);
}

/*
Function: removeInventoryItem
Description: Removes an inventory item from the inventory management service by its ID.
Parameter: const std::string& inventoryItemID - ID of the inventory item
Return type: void
*/
void Controller::removeInventoryItem(const std::string& inventoryItemID)
{
    m_inventoryManagementService.removeInventoryItem(inventoryItemID);
}

/*
Function: addInventoryItemStock
Description: Adds stock to an existing inventory item in the inventory management service.
Parameter: const std::string& selectedItemId - ID of the inventory item
           int quantity - quantity to add
Return type: void
*/
void Controller::addInventoryItemStock(const std::string& selectedItemId, int quantity)
{
    m_inventoryManagementService.addInventoryItemStock(selectedItemId, quantity);
}

/*
Function: getServiceBookings
Description: Retrieves all service bookings in read-only form.
Parameters:
    - None
Returns:
    - util::Map<std::string, const ServiceBooking*> containing service bookings
*/
util::Map<std::string, const ServiceBooking*> Controller::getServiceBookings()
{
    auto serviceBookings = m_serviceManagementService.getServiceBookings();
    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookings;
    for (int iterator = 0; iterator < serviceBookings.getSize(); iterator++)
    {
        readOnlyServiceBookings.insert(serviceBookings.getKeyAt(iterator), serviceBookings.getValueAt(iterator));
    }
    return readOnlyServiceBookings;
}

/*
Function: getServiceBookingsByUser
Description: Retrieves all service bookings for a specific user.
Parameters:
    - userID: std::string, the user ID
Returns:
    - util::Map<std::string, const ServiceBooking*> containing bookings for the user
*/
util::Map<std::string, const ServiceBooking*> Controller::getServiceBookingsByUser(const std::string userID)
{
    util::Map<std::string, const ServiceBooking*> readOnlyServiceBookingsByUserMap;
    util::Map<std::string, ServiceBooking*> currentServiceBookingsByUser = m_serviceManagementService.getServiceBookings(userID);
    for (int iterator = 0; iterator < currentServiceBookingsByUser.getSize(); iterator++)
    {
        readOnlyServiceBookingsByUserMap.insert(currentServiceBookingsByUser.getValueAt(iterator)->getId(), currentServiceBookingsByUser.getValueAt(iterator));
    }
    return readOnlyServiceBookingsByUserMap;
}

/*
Function: getUsers
Description: Retrieves all users from the user management service and
             constructs a read-only map.
Parameter: None
Return type: util::Map<std::string, const User*>
*/
util::Map<std::string, const User*> Controller::getUsers()
{
    auto listOfUsers = m_userManagementService.getUsers();
    util::Map<std::string, const User*> readOnlyUserList;
    for (int iterator = 0; iterator < listOfUsers.getSize(); iterator++)
    {
        readOnlyUserList.insert(listOfUsers.getKeyAt(iterator), listOfUsers.getValueAt(iterator));
    }
    return readOnlyUserList;
}

/*
Function: getUsers
Description: Retrieves users filtered by user type.
Parameters:
    - userType: util::UserType, type of user (CUSTOMER, TECHNICIAN, ADMIN)
Returns:
    - util::Map<std::string, const User*> containing users of the specified type
*/
util::Map<std::string, const User*> Controller::getUsers(util::UserType userType)
{
    auto userMap = m_userManagementService.getUsers(userType);
    util::Map<std::string, const User*> readOnlyUserMap;
    for (int iterator = 0; iterator < userMap.getSize(); iterator++)
    {
        readOnlyUserMap.insert(userMap.getKeyAt(iterator), userMap.getValueAt(iterator));
    }
    return readOnlyUserMap;
}

/*
Function: createJobCard
Description: Creates a job card for a service booking assigned to a technician.
Parameters:
    - bookingID: std::string, ID of the service booking
    - technicianID: std::string, ID of the technician
    - serviceID: std::string, ID of the service
Returns:
    - void
*/
void Controller::createJobCard(const std::string& bookingID, const std::string& technicianID, const std::string& serviceID)
{
    m_serviceManagementService.createJobCard(bookingID, technicianID, serviceID);
}

/*
Function: createService
Description: Creates a new service with associated inventory items and labor cost.
Parameters:
    - name: std::string, name of the service
    - inventoryItemIDs: Vector of inventory item IDs
    - laborCost: double, labor cost
Returns:
    - void
*/
void Controller::createService(const std::string& name, const util::Vector<std::string>& inventoryItemIDs, double laborCost)
{
    m_serviceManagementService.createService(name, inventoryItemIDs, laborCost);
}

/*
Function: removeService
Description: Removes a service from the system by ID.
Parameters:
    - serviceID: std::string, ID of the service
Returns:
    - void
*/
void Controller::removeService(const std::string& serviceID)
{
    m_serviceManagementService.removeService(serviceID);
}

/*
Function: getJobCardsByUser
Description: Retrieves job cards assigned to the authenticated technician.
Parameters:
    - None
Returns:
    - util::Map<std::string, const JobCard*> containing job cards
*/
util::Map<std::string, const JobCard*> Controller::getJobCardsByUser()
{
    const User* currentUser = getAuthenticatedUser();
    auto jobCardsAssignedToTechnician = m_serviceManagementService.getJobCards(currentUser->getId());
    util::Map<std::string, const JobCard*> readOnlyJobCardMap;
    for (int iterator = 0; iterator < jobCardsAssignedToTechnician.getSize(); iterator++)
    {
        JobCard* currentJobCard = jobCardsAssignedToTechnician.getValueAt(iterator);
        readOnlyJobCardMap.insert(currentJobCard->getId(), currentJobCard);
    }
    return readOnlyJobCardMap;
}

/*
Function: completeJob
Description: Marks a job card as completed.
Parameters:
    - jobID: std::string, ID of the job card
Returns:
    - void
*/
void Controller::updateJobStatus(const std::string& jobID)
{
    m_serviceManagementService.updateJobStatus(jobID);
}

/*
Function: removeUser
Description: Removes a user by ID. Cancels associated service bookings
             and technician jobs before removing the user from the system.
Parameter: const std::string& userID - ID of the user to remove
Return type: void
*/
void Controller::removeUser(const std::string& userID)
{
    User* user = m_userManagementService.getUser(userID);
    if (!user)
    {
        throw std::runtime_error("Error: User not Found.\n");
    }
    m_userManagementService.removeUser(userID);
}

/*
Function: createComboPackage
Description: Creates a new combo package with specified services and discount
             percentage by delegating to the service management service.
Parameter: const std::string& name - name of the combo package
           const util::Vector<std::string>& serviceIDs - list of service IDs
           double discountPercentage - discount percentage for the package
Return type: void
*/
void Controller::createComboPackage(const std::string& name, const util::Vector<std::string>& serviceIDs, double discountPercentage)
{
    m_serviceManagementService.createComboPackage(name, serviceIDs, discountPercentage);
}

/*
Function: removeComboPackage
Description: Removes a combo package by ID by delegating to the service
             management service.
Parameter: const std::string& comboPackageID - ID of the combo package
Return type: void
*/
void Controller::removeComboPackage(const std::string& comboPackageID)
{
    m_serviceManagementService.removeComboPackage(comboPackageID);
}

/*
Function: getInvoicesByUser
Description: Retrieves all invoices associated with the currently authenticated user.
             Converts them into a read-only map before returning.
Parameters:
    - None
Returns:
    - util::Map<std::string, const Invoice*> containing the user’s invoices
*/
util::Map<std::string, const Invoice*> Controller::getInvoicesByUser()
{
    User* currentUser = m_authenticationManagementService.getAuthenticatedUser();
    util::Map<std::string, Invoice*> currentUserInvoices =  m_paymentManagementService.getInvoices(currentUser->getId());
    util::Map<std::string, const Invoice*> userInvoicesReadOnly;
    for (int iterator = 0; iterator < currentUserInvoices.getSize(); iterator++)
    {
        Invoice* currentInvoice = currentUserInvoices.getValueAt(iterator);
        userInvoicesReadOnly.insert(currentInvoice->getId(), currentInvoice);
    }
    return userInvoicesReadOnly;
}

/*
Function: getAllInvoices
Description: Retrieves all invoices from the PaymentManagementService and returns them as a read-only map.
Parameters:
    - none
Returns:
    - util::Map<std::string, const Invoice*>: Map of invoice IDs to invoice objects
*/
util::Map<std::string, const Invoice*> Controller::getAllInvoices()
{
    auto invoices = m_paymentManagementService.getAllInvoices();
    util::Map<std::string, const Invoice*> readOnlyInvoice;
    for (int iterator = 0; iterator < invoices.getSize(); iterator++)
    {
        readOnlyInvoice.insert(invoices.getKeyAt(iterator), invoices.getValueAt(iterator));
    }
    return readOnlyInvoice;
}

/*
Function: confirmPayment
Description: Delegates payment confirmation for a given invoice ID to the PaymentManagementService.
Parameters:
    - invoiceID: std::string, ID of the invoice to confirm
Returns:
    - void
*/
void Controller::confirmPayment(const std::string& invoiceID)
{
    m_paymentManagementService.confirmPayment(invoiceID);
}

/*
Function: completePayment
Description: Completes payment for a specific invoice using the given payment mode.
Parameters:
    - invoiceID: std::string, ID of the invoice to be paid
    - paymentMode: util::PaymentMode, mode of payment (e.g., ONLINE, OFFLINE)
Returns:
    - void
*/
void Controller::completePayment(const std::string& invoiceID, util::PaymentMode paymentMode)
{
    m_paymentManagementService.completePayment(invoiceID, paymentMode);
}

/*
Function: getNotifications
Description: Retrieves all notifications for the currently authenticated user.
             Converts them into a read-only vector before returning.
Parameters: None
Return type: util::Vector<const Notification*>
*/
util::Vector<const Notification*> Controller::getNotifications()
{
    const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
    if (!authenticatedUser)
    {
        throw std::runtime_error("No user is currently logged in!");
    }
    auto notifications = m_userManagementService.getUserNotifications(authenticatedUser->getId());
    int numberOfNotifications = notifications.getSize();
    util::Vector<const Notification*> readOnlyNotifications;
    for (int index = 0; index < numberOfNotifications; index++)
    {
        readOnlyNotifications.push_back(notifications[index]);
    }
    return readOnlyNotifications;
}

/*
Function: deleteNotification
Description: Deletes a specific notification for the currently authenticated user.
Parameters:
    - notificationID: std::string, the unique identifier of the notification
Return type: void
*/
void Controller::deleteNotification(const std::string& notificationID)
{
    const User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
    if (!authenticatedUser)
    {
        throw std::runtime_error("No user is currently logged in!");
    }
    m_userManagementService.deleteNotification(notificationID, authenticatedUser->getId());
}

/*
Function: configureNotifications
Description: Configures notification preferences for the authenticated user.
             Attaches or detaches the user from payment and service notifications.
Parameters:
    - paymentNotifications: bool, enable/disable payment notifications
    - serviceNotifications: bool, enable/disable service notifications
Return type: void
*/
void Controller::configureNotifications(bool paymentNotifications, bool serviceNotifications)
{
    User* authenticatedUser = m_authenticationManagementService.getAuthenticatedUser();
    if (authenticatedUser)
    {
        if (paymentNotifications)
        {
            m_paymentManagementService.attach(authenticatedUser);
        }
        else
        {
            m_paymentManagementService.detach(authenticatedUser);
        }
        if (serviceNotifications)
        {
            m_serviceManagementService.attach(authenticatedUser);
        }
        else
        {
            m_serviceManagementService.detach(authenticatedUser);
        }
    }
    else
    {
        throw std::runtime_error("No user is currently logged in!");
    }
}

/*
Function: loadSystemData
Description: Loads all system data from persistent storage into memory.
             Invokes the respective management services to load users, inventory items, services,
             combo packages, service bookings, job cards, invoices, and observers.
Parameters:
    - None
Returns:
    - void
*/
void Controller::loadSystemData()
{
    m_userManagementService.loadUsers();
    m_inventoryManagementService.loadInventoryItems();
    m_serviceManagementService.loadServices();
    m_serviceManagementService.loadComboPackages();
    m_serviceManagementService.loadServiceBookings();
    m_serviceManagementService.loadJobCards();
    m_paymentManagementService.loadInvoices();
    m_serviceManagementService.loadObservers();
    m_paymentManagementService.loadObservers();
    m_inventoryManagementService.loadObservers();
}

/*
Function: saveSystemData
Description: Saves all system data from memory back to persistent storage.
             Invokes the respective management services to save users, inventory items, services,
             combo packages, service bookings, job cards, invoices, and observers.
Parameters:
    - None
Returns:
    - void
*/
void Controller::saveSystemData()
{
    m_userManagementService.saveUsers();
    m_inventoryManagementService.saveInventoryItems();
    m_serviceManagementService.saveServices();
    m_serviceManagementService.saveComboPackages();
    m_serviceManagementService.saveServiceBookings();
    m_serviceManagementService.saveJobCards();
    m_paymentManagementService.saveInvoices();
    m_serviceManagementService.saveObservers();
    m_paymentManagementService.saveObservers();
    m_inventoryManagementService.saveObservers();
}

/*
Function: runSystemChecks
Description: Runs system checks to ensure critical configurations, such as verifying admin existence.
Parameter: None
Return type: void
*/
void Controller::runSystemChecks()
{
    m_userManagementService.ensureAdminExists();
    m_inventoryManagementService.sendLowStockAlerts();
    m_paymentManagementService.sendPaymentReminders();
}