Training-VehicleService-May26/Trenser.VehicleServiceSystem/Trenser.VehicleServiceSystem/utilities/Utility.h

/*
File: Utility.h
Description: Header file declaring utility functions used across the system
Author: Trenser
Date:19-May-2026
*/

#pragma once
#include "ComboPackage.h"
#include "DataStore.h"
#include "FileHelper.h"
#include "InventoryItem.h"
#include "NotificationManagementService.h"
#include "Service.h"

namespace util
{
    /*
    Function: calculatePartsCost
    Description: Calculates the total cost of parts required for a given service
                 by summing the prices of all associated inventory items.
    Parameter: const Service* service - pointer to the service object
    Return type: double - total cost of required parts
    */
    inline double calculatePartsCost(const Service* service)
    {
        double cost = 0;
        auto& requiredInventoryItems = service->getRequiredInventoryItems();
        int requiredInventoryItemsSize = requiredInventoryItems.getSize();
        for (int index = 0; index < requiredInventoryItemsSize; index++)
        {
            cost += requiredInventoryItems.getValueAt(index)->getPrice();
        }
        return cost;
    }

    /*
    Function: calculateComboServiceEstimatedCost
    Description: Calculates the estimated total cost of a combo package by summing
                  the labor and parts costs of all services included in the package.
    Parameter: const ComboPackage* comboPackage - pointer to the combo package object
    Return type: double - estimated total cost of the combo package
    */
    inline double calculateComboServiceEstimatedCost(const ComboPackage* comboPackage)
    {
        double cost = 0;
        auto& services = comboPackage->getServices();
        int servicesSize = services.getSize();
        for (int index = 0; index < servicesSize; index++)
        {
            const Service* service = services.getValueAt(index);
            cost += calculatePartsCost(service) + service->getLaborCost();
        }
        return cost;
    }

    /*
    Function: loadObservers
    Description: Loads observer IDs from a file and attaches the corresponding users
                 to the notification management service. Validates that each observer ID
                 exists in the datastore before attaching.
    Parameters:
        - filePath: const std::string&, path to the file containing observer IDs
        - service: NotificationManagementService*, pointer to the notification service
        - dataStore: DataStore&, reference to the datastore containing users
    Returns:
        - void
    Throws:
        - std::runtime_error if an observer ID is invalid (not found in datastore)
    */
    inline void loadObservers(const std::string& filePath, NotificationManagementService* service, DataStore& dataStore)
    {
        auto observerIDs = util::loadRecords(filePath);
        auto& users = dataStore.getUsers();
        for (int index = 0; index < observerIDs.getSize(); index++)
        {
            const std::string& observerID = observerIDs[index];
            int userIndex = users.find(observerID);
            if (userIndex == -1)
            {
                throw std::runtime_error("Invalid Observer ID");
            }
            service->attach(users.getValueAt(userIndex));
        }
    }

    /*
    Function: saveObservers
    Description: Saves the current observer IDs from the notification management service
                 to a file for persistence.
    Parameters:
        - filePath: const std::string&, path to the file where observer IDs will be saved
        - service: NotificationManagementService*, pointer to the notification service
    Returns:
        - void
    */
    inline void saveObservers(const std::string& filePath, NotificationManagementService* service)
    {
        auto observerIDs = service->getObserverIDs();
        util::saveRecords(filePath, observerIDs);
    }

    template<typename TObject>
    Map<std::string, TObject*> getObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);

    template<typename TObject>
    Map<std::string, const TObject*> getConstObjects(const Map<std::string, TrackedRecord<TObject>>& trackedRecords);

    template<typename TObject>
    TrackedRecord<TObject> createNewRecord(TObject* object);
}

/*
Function: getObjects
Description: Extracts the object pointers from a tracked-record
             collection and returns them as a map keyed by the
             same identifiers.
Parameters:
    - trackedRecords: Collection of tracked records.
Returns:
    - Map<std::string, TObject*>: Collection of object pointers.
*/
template<typename TObject>
util::Map<std::string, TObject*> util::getObjects(const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
{
    util::Map<std::string, TObject*> objects;
    for (int index = 0; index < trackedRecords.getSize(); ++index)
    {
        const std::string& key = trackedRecords.getKeyAt(index);
        TObject* object = trackedRecords.getValueAt(index).data;
        objects.insert(key, object);
    }
    return objects;
}

/*
Function: getConstObjects
Description: Extracts the object pointers from a tracked-record
             collection and returns them as a read-only map
             keyed by the same identifiers.
Parameters:
    - trackedRecords: Collection of tracked records.
Returns:
    - Map<std::string, const TObject*>:
      Collection of read-only object pointers.
*/
template<typename TObject>
util::Map<std::string, const TObject*> util::getConstObjects(
    const util::Map<std::string, TrackedRecord<TObject>>& trackedRecords)
{
    util::Map<std::string, const TObject*> objects;
    for (int index = 0; index < trackedRecords.getSize(); ++index)
    {
        const std::string& key = trackedRecords.getKeyAt(index);
        const TObject* object = trackedRecords.getValueAt(index).data;
        objects.insert(key, object);
    }
    return objects;
}

/*
Function: createNewRecord
Description: Creates a tracked record for a newly created
             object. The record is initialized with
             NEW_RECORD state.
Parameters:
    - object: Pointer to the newly created object.
Returns:
    - TrackedRecord<TObject>: Initialized tracked record.
*/
template<typename TObject>
TrackedRecord<TObject> util::createNewRecord(TObject* object)
{
    TrackedRecord<TObject> record;
    record.data = object;
    record.state = RecordState::NEW_RECORD;
    return record;
}