/*
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: initialize
Description: Initializes the system and run system checks to ensure critical configurations, such as verifying admin existence.
Parameters:
    - None
Returns:
    - bool
*/
bool Controller::initialize()
{
    auto& dataStore = DataStore::getInstance();

    if (!dataStore.initialize())
    {
        return false;
    }
    m_userManagementService.ensureAdminExists();
    m_inventoryManagementService.sendLowStockAlerts();
    m_paymentManagementService.sendPaymentReminders();
    return true;
}

/*
Function: shutdown
Description: Shutdown the system, and do necessary cleanups
Parameters:
    - None
Returns:
    - void
*/
void Controller::shutdown()
{
    auto& dataStore = DataStore::getInstance();
    dataStore.shutdown();
}