#include "platform.hpp"

#include "common/types.hpp"
#include "common/utils.hpp"
#include "event_parser.hpp"
#include "file_lock.hpp"
#include "pdr.hpp"
#include "pdr_file.hpp"
#include "pdr_numeric_effecter.hpp"
#include "pdr_state_effecter.hpp"
#include "pdr_state_sensor.hpp"
#include "pdr_utils.hpp"
#include "platform_numeric_effecter.hpp"
#include "platform_state_effecter.hpp"
#include "platform_state_sensor.hpp"
#include "pldmd/handler.hpp"
#include "requester/handler.hpp"

#include <libpldm/entity.h>
#include <libpldm/state_set.h>
#include <sys/stat.h>
#include <unistd.h>

#include <phosphor-logging/lg2.hpp>

#include <memory>

PHOSPHOR_LOG2_USING;

using namespace pldm::utils;
using namespace pldm::responder::pdr;
using namespace pldm::responder::pdr_utils;

namespace pldm
{
namespace responder
{
namespace platform
{
using InternalFailure =
    sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;

static const Json empty{};

constexpr const char* ihFwLockFilePath = "/tmp/ih_fw.lock";

void Handler::addDbusObjMaps(
    uint16_t id,
    std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps> dbusObj,
    TypeId typeId)
{
    if (typeId == TypeId::PLDM_SENSOR_ID)
    {
        sensorDbusObjMaps.emplace(id, dbusObj);
    }
    else
    {
        effecterDbusObjMaps.emplace(id, dbusObj);
    }
}

const std::tuple<pdr_utils::DbusMappings, pdr_utils::DbusValMaps>&
    Handler::getDbusObjMaps(uint16_t id, TypeId typeId) const
{
    if (typeId == TypeId::PLDM_SENSOR_ID)
    {
        return sensorDbusObjMaps.at(id);
    }
    else
    {
        return effecterDbusObjMaps.at(id);
    }
}

void Handler::generate(const pldm::utils::DBusHandler* dBusIntf,
                       const std::vector<fs::path>& dir, Repo& repo)
{
    // Acquire the file lock before processing PDRs. We can pass the lock file
    // through a EM config later. We could also pass different locks based on
    // the directory. For now we are hardcoding the lock file path and using it
    // before opening any directory.
    const std::string lockFilePath = ihFwLockFilePath;
    std::unique_ptr<FileLock> lock;
    try
    {
        lock = std::make_unique<FileLock>(lockFilePath);
        info("Acquired lock on {LOCK_FILE}", "LOCK_FILE", lockFilePath);
    }
    catch (const std::runtime_error& e)
    {
        error(
            "Failed to acquire lock on {LOCK_FILE}: {ERROR}. Continuing without lock. There is a possibility of PDR config JSONs and corresponding files mismatch.",
            "LOCK_FILE", lockFilePath, "ERROR", e.what());
    }

    // Close and clear existing file info and snapshots to prevent leaks
    for (auto& [id, info] : fileIdentifierToFileInfo)
    {
        if (info.fp)
        {
            fclose(info.fp);
            info.fp = nullptr;
        }
    }
    fileIdentifierToFileInfo.clear();
    recordHandleToFileInfo.clear();

    for (auto& [tid, tidMap] : tidFileSnapshots)
    {
        for (auto& [id, info] : tidMap)
        {
            if (info.fp)
            {
                fclose(info.fp);
                info.fp = nullptr;
            }
        }
    }
    tidFileSnapshots.clear();

    // A map of PDR type to a lambda that handles creation of that PDR type.
    // The lambda essentially would parse the platform specific PDR JSONs to
    // generate the PDR structures. This function iterates through the map to
    // invoke all lambdas, so that all PDR types can be created.

    const std::map<Type, generatePDR> generateHandlers = {
        {PLDM_STATE_EFFECTER_PDR,
         [this](const DBusHandler& dBusIntf, const auto& json,
                RepoInterface& repo) {
             pdr_state_effecter::generateStateEffecterPDR<
                 pldm::utils::DBusHandler, Handler>(dBusIntf, json, *this,
                                                    repo);
         }},
        {PLDM_NUMERIC_EFFECTER_PDR,
         [this](const DBusHandler& dBusIntf, const auto& json,
                RepoInterface& repo) {
             pdr_numeric_effecter::generateNumericEffecterPDR<
                 pldm::utils::DBusHandler, Handler>(dBusIntf, json, *this,
                                                    repo);
         }},
        {PLDM_STATE_SENSOR_PDR, [this](const DBusHandler& dBusIntf,
                                       const auto& json, RepoInterface& repo) {
             pdr_state_sensor::generateStateSensorPDR<pldm::utils::DBusHandler,
                                                      Handler>(dBusIntf, json,
                                                               *this, repo);
         }}};

    Type pdrType{};
    for (const auto& directory : dir)
    {
        if (!fs::exists(directory))
        {
            error("PDR config directory '{PATH}' does not exist", "PATH",
                  directory);
            continue;
        }

        try
        {
            for (const auto& dirEntry : fs::directory_iterator(directory))
            {
                try
                {
                    if (fs::is_regular_file(dirEntry.path()) &&
                        dirEntry.path().extension() == ".json")
                    {
                        std::string configFilePath = dirEntry.path().string();
                        struct timespec config_last_modified{};
                        struct stat configStat;
                        if (stat(configFilePath.c_str(), &configStat) == 0)
                        {
                            config_last_modified = configStat.st_mtim;
                        }
                        else
                        {
                            error("Failed to stat config file {PATH}", "PATH",
                                  configFilePath);
                        }

                        auto json = readJson(configFilePath);
                        if (!json.empty())
                        {
                            auto filePdrs =
                                json.value("fileDescriptorPDRs", empty);
                            for (const auto& filePdrEntries : filePdrs)
                            {
                                pdr_file::generateFileDescriptorPDR(
                                    filePdrEntries, configFilePath,
                                    config_last_modified,
                                    fileIdentifierToFileInfo,
                                    recordHandleToFileInfo, repo);
                            }

                            auto effecterPDRs =
                                json.value("effecterPDRs", empty);
                            for (const auto& effecter : effecterPDRs)
                            {
                                pdrType = effecter.value("pdrType", 0);
                                if (dBusIntf)
                                {
                                    generateHandlers.at(
                                        pdrType)(*dBusIntf, effecter, repo);
                                }
                            }

                            auto sensorPDRs = json.value("sensorPDRs", empty);
                            for (const auto& sensor : sensorPDRs)
                            {
                                pdrType = sensor.value("pdrType", 0);
                                if (dBusIntf)
                                {
                                    generateHandlers.at(
                                        pdrType)(*dBusIntf, sensor, repo);
                                }
                            }
                        }
                    }
                }
                catch (const InternalFailure& e)
                {
                    error(
                        "PDR config directory '{PATH}' does not exist or empty for '{TYPE}' pdr, error - {ERROR}",
                        "PATH", dirEntry.path(), "TYPE", pdrType, "ERROR", e);
                }
                catch (const Json::exception& e)
                {
                    error(
                        "Failed to parse PDR JSON file {PATH}, error - {ERROR}",
                        "PATH", dirEntry.path(), "ERROR", e);
                    pldm::utils::reportError(
                        "xyz.openbmc_project.PLDM.Error.Generate.PDRJsonFileParseFail");
                }
                catch (const std::exception& e)
                {
                    error(
                        "Failed to parse PDR JSON file {PATH}, error - {ERROR}",
                        "PATH", dirEntry.path(), "ERROR", e);
                    pldm::utils::reportError(
                        "xyz.openbmc_project.PLDM.Error.Generate.PDRJsonFileParseFail");
                }
            }
        }
        catch (const fs::filesystem_error& e)
        {
            error(
                "Failed to iterate over PDR config directory '{PATH}', error - {ERROR}",
                "PATH", directory, "ERROR", e);
        }
    }

    // Release the lock when exiting the scope
    if (lock)
    {
        info("Released lock on {LOCK_FILE}", "LOCK_FILE", lockFilePath);
    }
}

bool Handler::isFileModified(uint16_t fileIdentifier)
{
    auto it = fileIdentifierToFileInfo.find(fileIdentifier);
    if (it == fileIdentifierToFileInfo.end())
    {
        error(
            "File identifier {FILE_ID} not found. Cannot check modification status.",
            "FILE_ID", fileIdentifier);
        return false;
    }

    const auto& fileInfo = it->second;
    struct stat fileStat;
    if (stat(fileInfo.filePath.c_str(), &fileStat) != 0)
    {
        error("Failed to stat file {FILE_PATH}", "FILE_PATH",
              fileInfo.filePath);
        // Treat as modified if stat fails, so that we attempt to refresh the
        // PDR and get a valid file pointer on next access. This is a safer
        // failure mode than treating it as unmodified, which might lead to
        // stale file pointers.
        return true;
    }

    if (fileStat.st_mtim.tv_sec > fileInfo.last_modified.tv_sec ||
        (fileStat.st_mtim.tv_sec == fileInfo.last_modified.tv_sec &&
         fileStat.st_mtim.tv_nsec > fileInfo.last_modified.tv_nsec))
    {
        info("File {FILE_PATH} (ID: {FILE_ID}) has been modified", "FILE_PATH",
             fileInfo.filePath, "FILE_ID", fileIdentifier);
        return true;
    }

    struct stat configStat;
    if (stat(fileInfo.configFilePath.c_str(), &configStat) != 0)
    {
        error("Failed to stat config file {FILE_PATH}", "FILE_PATH",
              fileInfo.configFilePath);
        return true;
    }

    if (configStat.st_mtim.tv_sec > fileInfo.config_last_modified.tv_sec ||
        (configStat.st_mtim.tv_sec == fileInfo.config_last_modified.tv_sec &&
         configStat.st_mtim.tv_nsec > fileInfo.config_last_modified.tv_nsec))
    {
        info(
            "Config file {FILE_PATH} (for File ID: {FILE_ID}) has been modified",
            "FILE_PATH", fileInfo.configFilePath, "FILE_ID", fileIdentifier);
        return true;
    }

    return false;
}

void Handler::refreshSingleFilePDR(uint16_t fileIdentifier)
{
    const std::string lockFilePath = ihFwLockFilePath;
    std::unique_ptr<FileLock> lock;
    try
    {
        lock = std::make_unique<FileLock>(lockFilePath);
        info("Acquired lock for PDR refresh on {LOCK_FILE}", "LOCK_FILE",
             lockFilePath);
    }
    catch (const std::runtime_error& e)
    {
        error(
            "Failed to acquire lock for PDR refresh: {ERROR}. Continuing PDR refresh without lock. There is a possibility of PDR config JSONs and corresponding files mismatch.",
            "ERROR", e.what());
    }

    auto it = fileIdentifierToFileInfo.find(fileIdentifier);
    if (it == fileIdentifierToFileInfo.end())
    {
        error("refreshSingleFilePDR: File ID {FID} not found", "FID",
              fileIdentifier);
        return;
    }
    pdr_file::FileInfo staleFileInfo = it->second;

    if (staleFileInfo.fp)
    {
        fclose(staleFileInfo.fp);
    }

    recordHandleToFileInfo.erase(staleFileInfo.recordHandle);
    fileIdentifierToFileInfo.erase(it);

    int del_rc = pldm_pdr_delete_by_record_handle(
        pdrRepo.getPdr(), staleFileInfo.recordHandle, false);
    if (del_rc != 0)
    {
        error("Failed to delete old PDR record {RH} for File ID {FID}, rc={RC}",
              "RH", staleFileInfo.recordHandle, "FID", fileIdentifier, "RC",
              del_rc);
        return;
    }

    nlohmann::json newFileEntry = staleFileInfo.fileJsonEntry;
    struct timespec config_last_modified = staleFileInfo.config_last_modified;

    struct stat configStat;
    if (stat(staleFileInfo.configFilePath.c_str(), &configStat) == 0)
    {
        config_last_modified = configStat.st_mtim;
        auto staleFileNameIt = staleFileInfo.fileJsonEntry.find("FileName");
        if (staleFileNameIt != staleFileInfo.fileJsonEntry.end() &&
            staleFileNameIt->is_string())
        {
            pdr_file::getFileEntryFromConfig(
                staleFileInfo.configFilePath,
                staleFileNameIt->get<std::string>(), newFileEntry);
        }
    }
    else
    {
        error("Failed to stat config file {PATH} during refresh", "PATH",
              staleFileInfo.configFilePath);
    }

    uint32_t recordHandle = staleFileInfo.recordHandle;
    if (!pdr_file::generateSingleFilePDR(
            newFileEntry, staleFileInfo.directoryPath, staleFileInfo.entityType,
            staleFileInfo.containerId, staleFileInfo.configFilePath,
            config_last_modified, fileIdentifierToFileInfo,
            recordHandleToFileInfo, pdrRepo, &recordHandle))
    {
        error("Failed to regenerate PDR for File ID {FID}", "FID",
              fileIdentifier);
        return;
    }

    if (recordHandle != staleFileInfo.recordHandle)
    {
        error(
            "PDR for File ID {FID} re-added with handle {NEW}, expected {OLD}",
            "FID", fileIdentifier, "NEW", recordHandle, "OLD",
            staleFileInfo.recordHandle);
        return;
    }

    info("Successfully refreshed PDR for File ID {FID}", "FID", fileIdentifier);
}

bool Handler::createFileSnapshot(pldm_tid_t tid, uint32_t recordHandle)
{
    pdr_utils::PdrEntry pdrEntry{};
    uint32_t recordHandleForSnapshot = recordHandle;
    // If record handle is 0, it means the requester is asking for the first
    // record.
    if (recordHandleForSnapshot == 0)
    {
        const pldm_pdr_record* firstRecord = pdrRepo.getFirstRecord(pdrEntry);
        if (firstRecord == nullptr)
        {
            error(
                "No records found in PDR repository when trying to create file snapshot for TID {TID}",
                "TID", tid);
            return false;
        }
        recordHandleForSnapshot = pdrRepo.getRecordHandle(firstRecord);
    }

    auto fileInforIter = recordHandleToFileInfo.find(recordHandleForSnapshot);
    if (fileInforIter == recordHandleToFileInfo.end())
    {
        error(
            "Record handle {RECORD_HANDLE} not found in recordHandleToFileInfo. Cannot create file snapshot.",
            "RECORD_HANDLE", recordHandleForSnapshot);
        return false;
    }

    uint16_t fileIdentifier = fileInforIter->second.fileIdentifier;
    uint16_t oldFileIdentifier = fileIdentifier;
    pdr_file::FileInfo snapshotFileInfo = fileInforIter->second;

    if (isFileModified(fileIdentifier))
    {
        info("File ID {FID} modified, refreshing its PDR...", "FID",
             fileIdentifier);
        refreshSingleFilePDR(fileIdentifier);
        auto newFileIter = recordHandleToFileInfo.find(recordHandleForSnapshot);
        if (newFileIter == recordHandleToFileInfo.end())
        {
            error(
                "Record handle {RH} not found in recordHandleToFileInfo after PDR refresh.",
                "RH", recordHandleForSnapshot);
            return false;
        }
        snapshotFileInfo = newFileIter->second;
        fileIdentifier = snapshotFileInfo.fileIdentifier;
    }

    // Clean up any previous snapshot for this TID and both old and new File IDs
    auto& tidMap = tidFileSnapshots[tid];

    std::vector<uint16_t> idsToClean = {fileIdentifier};
    if (oldFileIdentifier != fileIdentifier)
    {
        idsToClean.push_back(oldFileIdentifier);
    }

    for (uint16_t id : idsToClean)
    {
        auto snapIt = tidMap.find(id);
        if (snapIt != tidMap.end())
        {
            if (snapIt->second.fp)
            {
                info("Closing stale snapshot for TID {TID} File ID {FILE_ID}",
                     "TID", tid, "FILE_ID", id);
                fclose(snapIt->second.fp);
            }
            tidMap.erase(snapIt);
        }
    }

    // Calculate total snapshots across all TIDs
    size_t totalSnapshots = 0;
    for (const auto& [currentTid, currentTidMap] : tidFileSnapshots)
    {
        totalSnapshots += currentTidMap.size();
    }

    auto now = std::chrono::steady_clock::now();

    if (totalSnapshots >= maxSnapshots)
    {
        if (!ejectStaleSnapshot(now))
        {
            error(
                "Cannot create snapshot for TID {TID}. Maximum capacity ({LIMIT}) reached and no stale snapshots could be ejected.",
                "TID", tid, "LIMIT", maxSnapshots);
            return false;
        }
    }

    FILE* newFp = nullptr;
    uint32_t fileSize = 0;
    if (this->getFilePointer(fileIdentifier, &newFp, &fileSize) != 0)
    {
        error(
            "Failed to get file pointer for snapshot for TID {TID} File ID {FILE_ID}",
            "TID", tid, "FILE_ID", fileIdentifier);
        return false;
    }

    snapshotFileInfo.fp = newFp;
    snapshotFileInfo.fileSize = fileSize;
    snapshotFileInfo.snapshotCreationTime = now;
    tidMap[fileIdentifier] = snapshotFileInfo;
    info("Created snapshot for TID {TID} File ID {FILE_ID}", "TID", tid,
         "FILE_ID", fileIdentifier);
    return true;
}

bool Handler::ejectStaleSnapshot(
    const std::chrono::steady_clock::time_point& now)
{
    info(
        "Snapshot limit reached ({LIMIT}), looking for stale snapshots to eject.",
        "LIMIT", maxSnapshots);

    uint8_t oldestTid = 0;
    uint16_t oldestFileId = 0;
    std::chrono::steady_clock::duration maxAge =
        std::chrono::steady_clock::duration::zero();
    bool foundStale = false;

    for (const auto& [currentTid, currentTidMap] : tidFileSnapshots)
    {
        for (const auto& [currentFileId, info] : currentTidMap)
        {
            auto age = now - info.snapshotCreationTime;
            if (age > snapshotTimeout && age > maxAge)
            {
                maxAge = age;
                oldestTid = currentTid;
                oldestFileId = currentFileId;
                foundStale = true;
            }
        }
    }

    if (!foundStale)
    {
        return false;
    }

    auto& staleMap = tidFileSnapshots[oldestTid];
    auto staleIt = staleMap.find(oldestFileId);
    if (staleIt != staleMap.end())
    {
        if (staleIt->second.fp)
        {
            info(
                "Ejecting stale snapshot for TID {TID} File ID {FILE_ID} due to capacity constraints.",
                "TID", oldestTid, "FILE_ID", oldestFileId);
            fclose(staleIt->second.fp);
        }
        staleMap.erase(staleIt);
        return true;
    }
    return false;
}

bool Handler::isSnapshotValid(uint8_t tid, uint16_t fileIdentifier) const
{
    auto tidIt = tidFileSnapshots.find(tid);
    if (tidIt == tidFileSnapshots.end())
    {
        return false;
    }

    auto fileIt = tidIt->second.find(fileIdentifier);
    if (fileIt == tidIt->second.end())
    {
        return false;
    }

    auto now = std::chrono::steady_clock::now();
    if ((now - fileIt->second.snapshotCreationTime) > snapshotTimeout)
    {
        return false;
    }

    return true;
}

Response Handler::getPDR(pldm_tid_t tid, const pldm_msg* request,
                         size_t payloadLength)
{
    if (oemPlatformHandler)
    {
        auto rc = oemPlatformHandler->checkBMCState();
        if (rc != PLDM_SUCCESS)
        {
            return ccOnlyResponse(request, PLDM_ERROR_NOT_READY);
        }
    }

    // Build FRU table if not built, since entity association PDR's
    // are built when the FRU table is constructed.
    if (fruHandler)
    {
        fruHandler->buildFRUTable();
    }

    if (!pdrCreated)
    {
#ifdef GENERATE_TERMINUS_LOCATOR_PDR
        generateTerminusLocatorPDR(pdrRepo);
#endif
        if (platformConfigHandler)
        {
            auto systemType = platformConfigHandler->getPlatformName();
            if (systemType.has_value())
            {
                // In case of normal poweron , the system type would have been
                // already filled by entity manager when ever BMC reaches Ready
                // state. If this is not filled by time we get a getpdr request
                // we can assume that the entity manager service is not present
                // on this system & continue to build the common PDR's.
                pdrJsonsDir.push_back(pdrJsonDir / systemType.value());
            }
        }

        if (oemPlatformHandler != nullptr)
        {
            oemPlatformHandler->buildOEMPDR(pdrRepo);
        }
        generate(dBusIntf, pdrJsonsDir, pdrRepo);

        pdrCreated = true;

        if (dbusToPLDMEventHandler)
        {
            deferredGetPDREvent = std::make_unique<sdeventplus::source::Defer>(
                event,
                std::bind(std::mem_fn(&pldm::responder::platform::Handler::
                                          _processPostGetPDRActions),
                          this, std::placeholders::_1));
        }
    }

    Response response(sizeof(pldm_msg_hdr) + PLDM_GET_PDR_MIN_RESP_BYTES, 0);

    if (payloadLength != PLDM_GET_PDR_REQ_BYTES)
    {
        return CmdHandler::ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
    }

    uint32_t recordHandle{};
    uint32_t dataTransferHandle{};
    uint8_t transferOpFlag{};
    uint16_t reqSizeBytes{};
    uint16_t recordChangeNum{};

    auto rc = decode_get_pdr_req(request, payloadLength, &recordHandle,
                                 &dataTransferHandle, &transferOpFlag,
                                 &reqSizeBytes, &recordChangeNum);
    if (rc != PLDM_SUCCESS)
    {
        return CmdHandler::ccOnlyResponse(request, rc);
    }

    info("GetPDR request received with RecordHandle: {RECORD_HANDLE}",
         "RECORD_HANDLE", recordHandle);

    uint16_t respSizeBytes{};
    uint8_t* recordData = nullptr;
    try
    {
        pdr_utils::PdrEntry e;
        auto record = pdr::getRecordByHandle(pdrRepo, recordHandle, e);
        if (record == nullptr)
        {
            return CmdHandler::ccOnlyResponse(
                request, PLDM_PLATFORM_INVALID_RECORD_HANDLE);
        }

        pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(e.data);
        if (hdr->type == PLDM_FILE_DESCRIPTOR_PDR)
        {
            if (!createFileSnapshot(tid, recordHandle))
            {
                error(
                    "Failed to create file snapshot for TID {TID} and RecordHandle {RH}",
                    "TID", tid, "RH", recordHandle);
                return CmdHandler::ccOnlyResponse(request, PLDM_ERROR);
            }
        }

        // Re-fetch the record data as createFileSnapshot might have changed it
        record = pdr::getRecordByHandle(pdrRepo, recordHandle, e);
        if (record == nullptr)
        {
            error("PDR record {RH} vanished after snapshot creation", "RH",
                  recordHandle);
            return CmdHandler::ccOnlyResponse(request, PLDM_ERROR);
        }

        if (reqSizeBytes)
        {
            respSizeBytes = e.size;
            if (respSizeBytes > reqSizeBytes)
            {
                respSizeBytes = reqSizeBytes;
            }
            recordData = e.data;
        }
        response.resize(sizeof(pldm_msg_hdr) + PLDM_GET_PDR_MIN_RESP_BYTES +
                            respSizeBytes,
                        0);
        auto responsePtr = new (response.data()) pldm_msg;
        rc = encode_get_pdr_resp(
            request->hdr.instance_id, PLDM_SUCCESS, e.handle.nextRecordHandle,
            0, PLDM_START_AND_END, respSizeBytes, recordData, 0, responsePtr);
        if (rc != PLDM_SUCCESS)
        {
            return ccOnlyResponse(request, rc);
        }
    }
    catch (const std::exception& e)
    {
        error(
            "Failed to access PDR record handle '{RECORD_HANDLE}', error - {ERROR}",
            "RECORD_HANDLE", recordHandle, "ERROR", e);
        return CmdHandler::ccOnlyResponse(request, PLDM_ERROR);
    }
    return response;
}

int Handler::transferSnapshotFile(uint16_t fileIdentifier, uint8_t tid,
                                  FILE** fp, uint32_t* fileSize)
{
    auto tidIt = tidFileSnapshots.find(tid);
    if (tidIt == tidFileSnapshots.end())
    {
        error("No snapshots found for TID {TID}", "TID", tid);
        return -1;
    }

    auto& tidMap = tidIt->second;
    auto fileIt = tidMap.find(fileIdentifier);
    if (fileIt == tidMap.end())
    {
        error("No snapshot found for TID {TID} File ID {FILE_ID}", "TID", tid,
              "FILE_ID", fileIdentifier);
        return -1;
    }

    // Provide the pointer to the caller
    *fp = fileIt->second.fp;
    *fileSize = fileIt->second.fileSize;

    info("Provided snapshot for TID {TID} File ID {FILE_ID}", "TID", tid,
         "FILE_ID", fileIdentifier);
    return 0;
}

Response Handler::setStateEffecterStates(const pldm_msg* request,
                                         size_t payloadLength)
{
    Response response(
        sizeof(pldm_msg_hdr) + PLDM_SET_STATE_EFFECTER_STATES_RESP_BYTES, 0);
    auto responsePtr = new (response.data()) pldm_msg;
    uint16_t effecterId;
    uint8_t compEffecterCnt;
    constexpr auto maxCompositeEffecterCnt = 8;
    std::vector<set_effecter_state_field> stateField(maxCompositeEffecterCnt,
                                                     {0, 0});

    if ((payloadLength > PLDM_SET_STATE_EFFECTER_STATES_REQ_BYTES) ||
        (payloadLength < sizeof(effecterId) + sizeof(compEffecterCnt) +
                             sizeof(set_effecter_state_field)))
    {
        return CmdHandler::ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
    }

    int rc = decode_set_state_effecter_states_req(
        request, payloadLength, &effecterId, &compEffecterCnt,
        stateField.data());

    if (rc != PLDM_SUCCESS)
    {
        return CmdHandler::ccOnlyResponse(request, rc);
    }

    stateField.resize(compEffecterCnt);
    const pldm::utils::DBusHandler dBusIntf;
    uint16_t entityType{};
    uint16_t entityInstance{};
    uint16_t stateSetId{};

    if (isOemStateEffecter(*this, effecterId, compEffecterCnt, entityType,
                           entityInstance, stateSetId) &&
        oemPlatformHandler != nullptr &&
        !effecterDbusObjMaps.contains(effecterId))
    {
        rc = oemPlatformHandler->oemSetStateEffecterStatesHandler(
            entityType, entityInstance, stateSetId, compEffecterCnt, stateField,
            effecterId);
    }
    else
    {
        rc = platform_state_effecter::setStateEffecterStatesHandler<
            pldm::utils::DBusHandler, Handler>(dBusIntf, *this, effecterId,
                                               stateField);
    }
    if (rc != PLDM_SUCCESS)
    {
        return CmdHandler::ccOnlyResponse(request, rc);
    }

    rc = encode_set_state_effecter_states_resp(request->hdr.instance_id, rc,
                                               responsePtr);
    if (rc != PLDM_SUCCESS)
    {
        return ccOnlyResponse(request, rc);
    }

    return response;
}

Response Handler::platformEventMessage(const pldm_msg* request,
                                       size_t payloadLength)
{
    uint8_t formatVersion{};
    uint8_t tid{};
    uint8_t eventClass{};
    size_t offset{};

    auto rc = decode_platform_event_message_req(
        request, payloadLength, &formatVersion, &tid, &eventClass, &offset);
    if (rc != PLDM_SUCCESS)
    {
        return CmdHandler::ccOnlyResponse(request, rc);
    }

    if (eventClass == PLDM_HEARTBEAT_TIMER_ELAPSED_EVENT)
    {
        rc = PLDM_SUCCESS;
        if (oemPlatformHandler)
        {
            if (oemPlatformHandler->watchDogRunning())
            {
                oemPlatformHandler->resetWatchDogTimer();
            }
            else
            {
                oemPlatformHandler->setSurvTimer(tid, true);
            }
        }
    }
    else
    {
        try
        {
            const auto& handlers = eventHandlers.at(eventClass);
            bool oneFailedHandler = false;
            for (const auto& handler : handlers)
            {
                rc =
                    handler(request, payloadLength, formatVersion, tid, offset);
                if (rc != PLDM_SUCCESS)
                {
                    oneFailedHandler = true;
                }
            }
            if (oneFailedHandler)
            {
                return CmdHandler::ccOnlyResponse(request, rc);
            }
        }
        catch (const std::out_of_range& e)
        {
            error("Failed to handle platform event msg, error - {ERROR}",
                  "ERROR", e);
            return CmdHandler::ccOnlyResponse(request, PLDM_ERROR_INVALID_DATA);
        }
    }
    Response response(
        sizeof(pldm_msg_hdr) + PLDM_PLATFORM_EVENT_MESSAGE_RESP_BYTES, 0);
    auto responsePtr = new (response.data()) pldm_msg;

    rc = encode_platform_event_message_resp(request->hdr.instance_id, rc,
                                            PLDM_EVENT_NO_LOGGING, responsePtr);
    if (rc != PLDM_SUCCESS)
    {
        return ccOnlyResponse(request, rc);
    }

    return response;
}

int Handler::sensorEvent(const pldm_msg* request, size_t payloadLength,
                         uint8_t /*formatVersion*/, uint8_t tid,
                         size_t eventDataOffset)
{
    uint16_t sensorId{};
    uint8_t eventClass{};
    size_t eventClassDataOffset{};
    auto eventData =
        reinterpret_cast<const uint8_t*>(request->payload) + eventDataOffset;
    auto eventDataSize = payloadLength - eventDataOffset;

    auto rc = decode_sensor_event_data(eventData, eventDataSize, &sensorId,
                                       &eventClass, &eventClassDataOffset);
    if (rc != PLDM_SUCCESS)
    {
        return rc;
    }

    auto eventClassData = reinterpret_cast<const uint8_t*>(request->payload) +
                          eventDataOffset + eventClassDataOffset;
    auto eventClassDataSize =
        payloadLength - eventDataOffset - eventClassDataOffset;

    if (eventClass == PLDM_STATE_SENSOR_STATE)
    {
        uint8_t sensorOffset{};
        uint8_t eventState{};
        uint8_t previousEventState{};

        rc = decode_state_sensor_data(eventClassData, eventClassDataSize,
                                      &sensorOffset, &eventState,
                                      &previousEventState);
        if (rc != PLDM_SUCCESS)
        {
            return PLDM_ERROR;
        }

        // Emitting state sensor event signal
        emitStateSensorEventSignal(tid, sensorId, sensorOffset, eventState,
                                   previousEventState);

        // If there are no HOST PDR's, there is no further action
        if (hostPDRHandler == nullptr)
        {
            return PLDM_SUCCESS;
        }

        // Handle PLDM events for which PDR is available
        SensorEntry sensorEntry{tid, sensorId};

        pldm::pdr::EntityInfo entityInfo{};
        pldm::pdr::CompositeSensorStates compositeSensorStates{};
        std::vector<pldm::pdr::StateSetId> stateSetIds{};

        try
        {
            std::tie(entityInfo, compositeSensorStates, stateSetIds) =
                hostPDRHandler->lookupSensorInfo(sensorEntry);
        }
        catch (const std::out_of_range&)
        {
            // If there is no mapping for tid, sensorId combination, try
            // PLDM_TID_RESERVED, sensorId for terminus that is yet to
            // implement TL PDR.
            try
            {
                sensorEntry.terminusID = PLDM_TID_RESERVED;
                std::tie(entityInfo, compositeSensorStates, stateSetIds) =
                    hostPDRHandler->lookupSensorInfo(sensorEntry);
            }
            // If there is no mapping for events return PLDM_SUCCESS
            catch (const std::out_of_range&)
            {
                return PLDM_SUCCESS;
            }
        }

        if (sensorOffset >= compositeSensorStates.size())
        {
            return PLDM_ERROR_INVALID_DATA;
        }

        const auto& possibleStates = compositeSensorStates[sensorOffset];
        if (!possibleStates.contains(eventState))
        {
            return PLDM_ERROR_INVALID_DATA;
        }

        const auto& [containerId, entityType, entityInstance] = entityInfo;
        events::StateSensorEntry stateSensorEntry{
            containerId,
            entityType,
            entityInstance,
            sensorOffset,
            stateSetIds[sensorOffset],
            false};
        return hostPDRHandler->handleStateSensorEvent(stateSensorEntry,
                                                      eventState);
    }
    else
    {
        return PLDM_ERROR_INVALID_DATA;
    }

    return PLDM_SUCCESS;
}

int Handler::pldmPDRRepositoryChgEvent(
    const pldm_msg* request, size_t payloadLength, uint8_t /*formatVersion*/,
    uint8_t tid, size_t eventDataOffset)
{
    uint8_t eventDataFormat{};
    uint8_t eventDataOperation{};
    uint8_t numberOfChangeRecords{};
    size_t dataOffset{};

    auto eventData =
        reinterpret_cast<const uint8_t*>(request->payload) + eventDataOffset;
    auto eventDataSize = payloadLength - eventDataOffset;

    auto rc = decode_pldm_pdr_repository_chg_event_data(
        eventData, eventDataSize, &eventDataFormat, &numberOfChangeRecords,
        &dataOffset);
    if (rc != PLDM_SUCCESS)
    {
        return rc;
    }

    PDRRecordHandles pdrRecordHandles;

    if (eventDataFormat == FORMAT_IS_PDR_TYPES)
    {
        return PLDM_ERROR_INVALID_DATA;
    }

    if (eventDataFormat == FORMAT_IS_PDR_HANDLES)
    {
        uint8_t numberOfChangeEntries{};

        auto changeRecordData = eventData + dataOffset;
        auto changeRecordDataSize = eventDataSize - dataOffset;

        while (changeRecordDataSize)
        {
            rc = decode_pldm_pdr_repository_change_record_data(
                changeRecordData, changeRecordDataSize, &eventDataOperation,
                &numberOfChangeEntries, &dataOffset);

            if (rc != PLDM_SUCCESS)
            {
                return rc;
            }

            if (eventDataOperation == PLDM_RECORDS_MODIFIED)
            {
                hostPDRHandler->isHostPdrModified = true;
            }

            rc = getPDRRecordHandles(
                reinterpret_cast<const ChangeEntry*>(
                    changeRecordData + dataOffset),
                changeRecordDataSize - dataOffset,
                static_cast<size_t>(numberOfChangeEntries), pdrRecordHandles);

            if (rc != PLDM_SUCCESS)
            {
                error("Invalid data, no pdr handles found");
                return rc;
            }

            changeRecordData +=
                dataOffset + (numberOfChangeEntries * sizeof(ChangeEntry));
            changeRecordDataSize -=
                dataOffset + (numberOfChangeEntries * sizeof(ChangeEntry));
        }
    }
    if (hostPDRHandler)
    {
        // if we get a Repository change event with the eventDataFormat
        // as REFRESH_ENTIRE_REPOSITORY, then delete all the PDR's that
        // have the matched Terminus handle
        if (eventDataFormat == REFRESH_ENTIRE_REPOSITORY)
        {
            // We cannot get the Repo change event from the Terminus
            // that is not already added to the BMC repository

            for (auto it = hostPDRHandler->tlPDRInfo.cbegin();
                 it != hostPDRHandler->tlPDRInfo.cend();)
            {
                if (std::get<0>(it->second) == tid)
                {
                    pldm_pdr_remove_pdrs_by_terminus_handle(pdrRepo.getPdr(),
                                                            it->first);
                    hostPDRHandler->tlPDRInfo.erase(it++);
                }
                else
                {
                    ++it;
                }
            }
        }
        if (eventDataOperation == PLDM_RECORDS_DELETED)
        {
            hostPDRHandler->deletePDRFromRepo(std::move(pdrRecordHandles));
        }
        else
        {
            hostPDRHandler->fetchPDR(std::move(pdrRecordHandles));
        }
    }

    return PLDM_SUCCESS;
}

int Handler::getPDRRecordHandles(
    const ChangeEntry* changeEntryData, size_t changeEntryDataSize,
    size_t numberOfChangeEntries, PDRRecordHandles& pdrRecordHandles)
{
    if (numberOfChangeEntries > (changeEntryDataSize / sizeof(ChangeEntry)))
    {
        return PLDM_ERROR_INVALID_DATA;
    }
    for (size_t i = 0; i < numberOfChangeEntries; i++)
    {
        pdrRecordHandles.push_back(changeEntryData[i]);
    }
    return PLDM_SUCCESS;
}

Response Handler::getNumericEffecterValue(const pldm_msg* request,
                                          size_t payloadLength)
{
    if (payloadLength != PLDM_GET_NUMERIC_EFFECTER_VALUE_REQ_BYTES)
    {
        return ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
    }

    uint16_t effecterId{};
    auto rc = decode_get_numeric_effecter_value_req(request, payloadLength,
                                                    &effecterId);
    if (rc != PLDM_SUCCESS)
    {
        return ccOnlyResponse(request, rc);
    }

    const pldm::utils::DBusHandler dBusIntf;
    uint8_t effecterDataSize{};
    pldm::utils::PropertyValue dbusValue;
    std::string propertyType;
    using effecterOperationalState = uint8_t;
    using completionCode = uint8_t;

    rc = platform_numeric_effecter::getNumericEffecterData<
        pldm::utils::DBusHandler, Handler>(
        dBusIntf, *this, effecterId, effecterDataSize, propertyType, dbusValue);

    if (rc != PLDM_SUCCESS)
    {
        return ccOnlyResponse(request, rc);
    }

    // Refer DSP0248_1.2.0.pdf (section 22.3, Table 48)
    // Completion Code (uint8), Effecter Data Size(uint8), Effecter Operational
    // State(uint8), PendingValue (uint8|sint8|uint16|sint16|uint32|sint32 )
    // PresentValue (uint8|sint8|uint16|sint16|uint32|sint32 )
    // Size of PendingValue and PresentValue calculated based on size is
    // provided in effecter data size
    size_t responsePayloadLength =
        sizeof(completionCode) + sizeof(effecterDataSize) +
        sizeof(effecterOperationalState) +
        getEffecterDataSize(effecterDataSize) +
        getEffecterDataSize(effecterDataSize);

    Response response(responsePayloadLength + sizeof(pldm_msg_hdr));
    auto responsePtr = new (response.data()) pldm_msg;

    rc = platform_numeric_effecter::getNumericEffecterValueHandler(
        propertyType, dbusValue, effecterDataSize, responsePtr,
        responsePayloadLength, request->hdr.instance_id);

    if (rc != PLDM_SUCCESS)
    {
        error(
            "Failed to get response of GetNumericEffecterValue for effecter ID '{EFFECTERID}', response code '{RC}'.",
            "EFFECTERID", effecterId, "RC", rc);
        return ccOnlyResponse(request, rc);
    }
    return response;
}

Response Handler::setNumericEffecterValue(const pldm_msg* request,
                                          size_t payloadLength)
{
    Response response(
        sizeof(pldm_msg_hdr) + PLDM_SET_NUMERIC_EFFECTER_VALUE_RESP_BYTES);
    uint16_t effecterId{};
    uint8_t effecterDataSize{};
    uint8_t effecterValue[4] = {};

    if ((payloadLength > sizeof(effecterId) + sizeof(effecterDataSize) +
                             sizeof(union_effecter_data_size)) ||
        (payloadLength < sizeof(effecterId) + sizeof(effecterDataSize) + 1))
    {
        return ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
    }

    int rc = decode_set_numeric_effecter_value_req(
        request, payloadLength, &effecterId, &effecterDataSize, effecterValue);

    if (rc == PLDM_SUCCESS)
    {
        const pldm::utils::DBusHandler dBusIntf;
        rc = platform_numeric_effecter::setNumericEffecterValueHandler<
            pldm::utils::DBusHandler, Handler>(
            dBusIntf, *this, effecterId, effecterDataSize, effecterValue,
            sizeof(effecterValue));
    }

    return ccOnlyResponse(request, rc);
}

void Handler::generateTerminusLocatorPDR(Repo& repo)
{
    std::vector<uint8_t> pdrBuffer(sizeof(pldm_terminus_locator_pdr));

    auto pdr = new (pdrBuffer.data()) pldm_terminus_locator_pdr;

    pdr->hdr.record_handle = 0;
    pdr->hdr.version = 1;
    pdr->hdr.type = PLDM_TERMINUS_LOCATOR_PDR;
    pdr->hdr.record_change_num = 0;
    pdr->hdr.length = sizeof(pldm_terminus_locator_pdr) - sizeof(pldm_pdr_hdr);
    pdr->terminus_handle = TERMINUS_HANDLE;
    pdr->validity = PLDM_TL_PDR_VALID;
    pdr->tid = TERMINUS_ID;
    pdr->container_id = 0x0;
    pdr->terminus_locator_type = PLDM_TERMINUS_LOCATOR_TYPE_MCTP_EID;
    pdr->terminus_locator_value_size =
        sizeof(pldm_terminus_locator_type_mctp_eid);
    auto locatorValue = new (pdr->terminus_locator_value)
        pldm_terminus_locator_type_mctp_eid;
    locatorValue->eid = pldm::BmcMctpEid;

    PdrEntry pdrEntry{};
    pdrEntry.data = pdrBuffer.data();
    pdrEntry.size = pdrBuffer.size();
    repo.addRecord(pdrEntry);
    if (hostPDRHandler)
    {
        hostPDRHandler->tlPDRInfo.insert_or_assign(
            pdr->terminus_handle,
            std::make_tuple(pdr->tid, locatorValue->eid, pdr->validity));
    }
}

Response Handler::getStateSensorReadings(const pldm_msg* request,
                                         size_t payloadLength)
{
    uint16_t sensorId{};
    bitfield8_t sensorRearm{};
    uint8_t reserved{};

    if (payloadLength != PLDM_GET_STATE_SENSOR_READINGS_REQ_BYTES)
    {
        return ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
    }

    int rc = decode_get_state_sensor_readings_req(
        request, payloadLength, &sensorId, &sensorRearm, &reserved);

    if (rc != PLDM_SUCCESS)
    {
        return ccOnlyResponse(request, rc);
    }

    // 0x01 to 0x08
    uint8_t sensorRearmCount = std::popcount(sensorRearm.byte);
    std::vector<get_sensor_state_field> stateField(sensorRearmCount);
    uint8_t comSensorCnt{};
    const pldm::utils::DBusHandler dBusIntf;

    uint16_t entityType{};
    uint16_t entityInstance{};
    uint16_t stateSetId{};
    uint16_t containerId{};

    if (isOemStateSensor(*this, sensorId, sensorRearmCount, comSensorCnt,
                         entityType, entityInstance, stateSetId, containerId) &&
        oemPlatformHandler && !sensorDbusObjMaps.contains(sensorId))
    {
        rc = oemPlatformHandler->getOemStateSensorReadingsHandler(
            entityType, entityInstance, containerId, stateSetId, comSensorCnt,
            sensorId, stateField);
    }
    else
    {
        rc = platform_state_sensor::getStateSensorReadingsHandler<
            pldm::utils::DBusHandler, Handler>(
            dBusIntf, *this, sensorId, sensorRearmCount, comSensorCnt,
            stateField, dbusToPLDMEventHandler->getSensorCache());
    }

    if (rc != PLDM_SUCCESS)
    {
        return ccOnlyResponse(request, rc);
    }

    Response response(
        sizeof(pldm_msg_hdr) + PLDM_GET_STATE_SENSOR_READINGS_MIN_RESP_BYTES +
        sizeof(get_sensor_state_field) * comSensorCnt);
    auto responsePtr = new (response.data()) pldm_msg;
    rc = encode_get_state_sensor_readings_resp(
        request->hdr.instance_id, rc, comSensorCnt, stateField.data(),
        responsePtr);
    if (rc != PLDM_SUCCESS)
    {
        return ccOnlyResponse(request, rc);
    }

    return response;
}

void Handler::_processPostGetPDRActions(sdeventplus::source::EventBase&
                                        /*source */)
{
    deferredGetPDREvent.reset();
    dbusToPLDMEventHandler->listenSensorEvent(pdrRepo, sensorDbusObjMaps);
}

bool isOemStateSensor(Handler& handler, uint16_t sensorId,
                      uint8_t sensorRearmCount, uint8_t& compSensorCnt,
                      uint16_t& entityType, uint16_t& entityInstance,
                      uint16_t& stateSetId, uint16_t& containerId)
{
    pldm_state_sensor_pdr* pdr = nullptr;

    std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> stateSensorPdrRepo(
        pldm_pdr_init(), pldm_pdr_destroy);
    if (!stateSensorPdrRepo)
    {
        error("Failed to instantiate state sensor PDR repository");
        return false;
    }
    Repo stateSensorPDRs(stateSensorPdrRepo.get());
    getRepoByType(handler.getRepo(), stateSensorPDRs, PLDM_STATE_SENSOR_PDR);
    if (stateSensorPDRs.empty())
    {
        error("Failed to get record by PDR type");
        return false;
    }

    PdrEntry pdrEntry{};
    auto pdrRecord = stateSensorPDRs.getFirstRecord(pdrEntry);
    while (pdrRecord)
    {
        pdr = new (pdrEntry.data) pldm_state_sensor_pdr;
        assert(pdr != nullptr);
        if (pdr->sensor_id != sensorId)
        {
            pdr = nullptr;
            pdrRecord = stateSensorPDRs.getNextRecord(pdrRecord, pdrEntry);
            continue;
        }
        auto tmpEntityType = pdr->entity_type;
        auto tmpEntityInstance = pdr->entity_instance;
        auto tmpEntityContainerId = pdr->container_id;
        auto tmpCompSensorCnt = pdr->composite_sensor_count;
        auto tmpPossibleStates =
            reinterpret_cast<state_sensor_possible_states*>(
                pdr->possible_states);
        auto tmpStateSetId = tmpPossibleStates->state_set_id;

        if (sensorRearmCount > tmpCompSensorCnt)
        {
            error(
                "The requester sent wrong sensor rearm count '{SENSOR_REARM_COUNT}' for the sensor ID '{SENSORID}'.",
                "SENSOR_REARM_COUNT", (uint16_t)sensorRearmCount, "SENSORID",
                sensorId);
            break;
        }

        if ((tmpEntityType >= PLDM_OEM_ENTITY_TYPE_START &&
             tmpEntityType <= PLDM_OEM_ENTITY_TYPE_END) ||
            (tmpStateSetId >= PLDM_OEM_STATE_SET_ID_START &&
             tmpStateSetId < PLDM_OEM_STATE_SET_ID_END))
        {
            entityType = tmpEntityType;
            entityInstance = tmpEntityInstance;
            stateSetId = tmpStateSetId;
            compSensorCnt = tmpCompSensorCnt;
            containerId = tmpEntityContainerId;
            return true;
        }
        else
        {
            return false;
        }
    }
    return false;
}

bool isOemStateEffecter(Handler& handler, uint16_t effecterId,
                        uint8_t compEffecterCnt, uint16_t& entityType,
                        uint16_t& entityInstance, uint16_t& stateSetId)
{
    pldm_state_effecter_pdr* pdr = nullptr;

    std::unique_ptr<pldm_pdr, decltype(&pldm_pdr_destroy)> stateEffecterPdrRepo(
        pldm_pdr_init(), pldm_pdr_destroy);
    if (!stateEffecterPdrRepo)
    {
        error("Failed to instantiate state effecter PDR repository");
        return false;
    }
    Repo stateEffecterPDRs(stateEffecterPdrRepo.get());
    getRepoByType(handler.getRepo(), stateEffecterPDRs,
                  PLDM_STATE_EFFECTER_PDR);
    if (stateEffecterPDRs.empty())
    {
        error("Failed to get record by PDR type");
        return false;
    }

    PdrEntry pdrEntry{};
    auto pdrRecord = stateEffecterPDRs.getFirstRecord(pdrEntry);
    while (pdrRecord)
    {
        pdr = new (pdrEntry.data) pldm_state_effecter_pdr;
        assert(pdr != nullptr);
        if (pdr->effecter_id != effecterId)
        {
            pdr = nullptr;
            pdrRecord = stateEffecterPDRs.getNextRecord(pdrRecord, pdrEntry);
            continue;
        }

        auto tmpEntityType = pdr->entity_type;
        auto tmpEntityInstance = pdr->entity_instance;
        auto tmpPossibleStates =
            reinterpret_cast<state_effecter_possible_states*>(
                pdr->possible_states);
        auto tmpStateSetId = tmpPossibleStates->state_set_id;

        if (compEffecterCnt > pdr->composite_effecter_count)
        {
            error(
                "The requester sent wrong composite effecter count '{COMPOSITE_EFFECTER_COUNT}' for the effecter ID '{EFFECTERID}'.",
                "COMPOSITE_EFFECTER_COUNT", compEffecterCnt, "EFFECTERID",
                effecterId);
            return false;
        }

        if ((tmpEntityType >= PLDM_OEM_ENTITY_TYPE_START &&
             tmpEntityType <= PLDM_OEM_ENTITY_TYPE_END) ||
            (tmpStateSetId >= PLDM_OEM_STATE_SET_ID_START &&
             tmpStateSetId < PLDM_OEM_STATE_SET_ID_END))
        {
            entityType = tmpEntityType;
            entityInstance = tmpEntityInstance;
            stateSetId = tmpStateSetId;
            return true;
        }
        else
        {
            return false;
        }
    }
    return false;
}

void Handler::setEventReceiver()
{
    std::vector<uint8_t> requestMsg(
        sizeof(pldm_msg_hdr) + PLDM_SET_EVENT_RECEIVER_REQ_BYTES);
    auto request = new (requestMsg.data()) pldm_msg;
    auto instanceIdResult = instanceIdDb->next(eid);
    if (!instanceIdResult)
    {
        throw pldm::InstanceIdError(instanceIdResult.error());
    }
    auto instanceId = instanceIdResult.value();
    uint8_t eventMessageGlobalEnable =
        PLDM_EVENT_MESSAGE_GLOBAL_ENABLE_ASYNC_KEEP_ALIVE;
    uint8_t transportProtocolType = PLDM_TRANSPORT_PROTOCOL_TYPE_MCTP;
    uint8_t eventReceiverAddressInfo = pldm::BmcMctpEid;
    uint16_t heartbeatTimer = HEARTBEAT_TIMEOUT;

    auto rc = encode_set_event_receiver_req(
        instanceId, eventMessageGlobalEnable, transportProtocolType,
        eventReceiverAddressInfo, heartbeatTimer, request);
    if (rc != PLDM_SUCCESS)
    {
        instanceIdDb->free(eid, instanceId);
        error(
            "Failed to encode set event receiver request, response code '{RC}'",
            "RC", lg2::hex, rc);
        return;
    }

    auto processSetEventReceiverResponse = [](mctp_eid_t /*eid*/,
                                              const pldm_msg* response,
                                              size_t respMsgLen) {
        if (response == nullptr || !respMsgLen)
        {
            error("Failed to receive response for setEventReceiver command");
            return;
        }

        uint8_t completionCode{};
        auto rc = decode_set_event_receiver_resp(response, respMsgLen,
                                                 &completionCode);
        if (rc || completionCode)
        {
            error(
                "Failed to decode setEventReceiver command, response code '{RC}' and completion code '{CC}'",
                "RC", rc, "CC", completionCode);
            pldm::utils::reportError(
                "xyz.openbmc_project.bmc.pldm.InternalFailure");
        }
    };
    rc = handler->registerRequest(
        eid, instanceId, PLDM_PLATFORM, PLDM_SET_EVENT_RECEIVER,
        std::move(requestMsg), std::move(processSetEventReceiverResponse));

    if (rc != PLDM_SUCCESS)
    {
        error("Failed to send the setEventReceiver request");
    }

    if (oemPlatformHandler)
    {
        oemPlatformHandler->countSetEventReceiver();
        oemPlatformHandler->checkAndDisableWatchDog();
    }
}

void Handler::sendPDRRepositoryChgEventbyPDRHandles(
    const std::vector<ChangeEntry>& pdrRecordHandles,
    const std::vector<uint8_t>& eventDataOps)
{
    uint8_t eventDataFormat = FORMAT_IS_PDR_HANDLES;
    std::vector<uint8_t> numsOfChangeEntries(1);
    std::vector<std::vector<ChangeEntry>> changeEntries(
        numsOfChangeEntries.size());
    for (auto pdrRecordHandle : pdrRecordHandles)
    {
        changeEntries[0].push_back(pdrRecordHandle);
    }
    if (changeEntries.empty())
    {
        return;
    }
    numsOfChangeEntries[0] = changeEntries[0].size();
    size_t maxSize = PLDM_PDR_REPOSITORY_CHG_EVENT_MIN_LENGTH +
                     PLDM_PDR_REPOSITORY_CHANGE_RECORD_MIN_LENGTH +
                     changeEntries[0].size() * sizeof(uint32_t);
    std::vector<uint8_t> eventDataVec{};
    eventDataVec.resize(maxSize);
    auto eventData =
        reinterpret_cast<struct pldm_pdr_repository_chg_event_data*>(
            eventDataVec.data());
    size_t actualSize{};
    auto firstEntry = changeEntries[0].data();
    auto rc = encode_pldm_pdr_repository_chg_event_data(
        eventDataFormat, 1, eventDataOps.data(), numsOfChangeEntries.data(),
        &firstEntry, eventData, &actualSize, maxSize);
    if (rc != PLDM_SUCCESS)
    {
        error(
            "Failed to encode the repository change event data with response code '{RC}'",
            "RC", static_cast<int>(rc));
        return;
    }
    auto instanceIdResult = instanceIdDb->next(eid);
    if (!instanceIdResult)
    {
        throw pldm::InstanceIdError(instanceIdResult.error());
    }
    auto instanceId = instanceIdResult.value();
    std::vector<uint8_t> requestMsg(
        sizeof(pldm_msg_hdr) + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES +
        actualSize);
    auto request = new (requestMsg.data()) pldm_msg;
    rc = encode_platform_event_message_req(
        instanceId, 1, TERMINUS_ID, PLDM_PDR_REPOSITORY_CHG_EVENT,
        eventDataVec.data(), actualSize, request,
        actualSize + PLDM_PLATFORM_EVENT_MESSAGE_MIN_REQ_BYTES);
    if (rc != PLDM_SUCCESS)
    {
        instanceIdDb->free(eid, instanceId);
        error(
            "Failed to encode the platform event message with response code '{RC}'",
            "RC", static_cast<unsigned>(rc));
        return;
    }
    auto platformEventMessageResponseHandler = [](mctp_eid_t /*eid*/,
                                                  const pldm_msg* response,
                                                  size_t respMsgLen) {
        if (response == nullptr || !respMsgLen)
        {
            error(
                "Failed to receive response for the PDR repository changed event");
            return;
        }
        uint8_t completionCode{};
        uint8_t status{};
        auto responsePtr = reinterpret_cast<const struct pldm_msg*>(response);
        auto rc = decode_platform_event_message_resp(responsePtr, respMsgLen,
                                                     &completionCode, &status);
        if (rc || completionCode)
        {
            error(
                "Failed to decode platform event message with response code '{RC}' and completion code '{CC}'",
                "RC", static_cast<int>(rc), "CC",
                static_cast<unsigned>(completionCode));
        }
    };
    rc = handler->registerRequest(
        eid, instanceId, PLDM_PLATFORM, PLDM_PLATFORM_EVENT_MESSAGE,
        std::move(requestMsg), std::move(platformEventMessageResponseHandler));
    if (rc)
    {
        error(
            "Failed to send the PDR repository changed event request after CM");
    }
}

Response Handler::getPdrRepositoryInfo(const pldm_msg* request,
                                       size_t payloadLength)
{
    // GetPDRRepositoryInfo request payload should be 0.
    if (payloadLength > 0)
    {
        return CmdHandler::ccOnlyResponse(request, PLDM_ERROR_INVALID_LENGTH);
    }

    Response response(
        sizeof(pldm_msg_hdr) + sizeof(pldm_pdr_repository_info_resp));
    auto responsePtr = new (response.data()) pldm_msg;

    // TODO: Support update times. Currently set to all 0.
    uint8_t updateTime[PLDM_TIMESTAMP104_SIZE];
    memset(updateTime, 0, PLDM_TIMESTAMP104_SIZE);

    uint8_t repository_state =
        pdrCreated ? PLDM_AVAILABLE : PLDM_UPDATE_IN_PROGRESS;

    int rc = encode_get_pdr_repository_info_resp(
        request->hdr.instance_id, PLDM_SUCCESS, repository_state, updateTime,
        updateTime, pdrRepo.getRecordCount(), pdrRepo.getRepositorySize(),
        pdrRepo.getLargestRecordSize(), /*data_transfer_handle_timeout=*/0,
        responsePtr);
    if (rc != PLDM_SUCCESS)
    {
        return ccOnlyResponse(request, rc);
    }

    return response;
}

int Handler::getFilePointer(uint16_t fileIdentifier, FILE** fp,
                            uint32_t* fileSize)
{
    auto it = fileIdentifierToFileInfo.find(fileIdentifier);
    if (it == fileIdentifierToFileInfo.end())
    {
        error(
            "File identifier '{FILE_ID}' not found in fileIdentifierToFileInfo map",
            "FILE_ID", fileIdentifier);
        return -1;
    }

    FILE* original_fp = it->second.fp;
    if (original_fp == nullptr)
    {
        error("Invalid file pointer for file identifier '{FILE_ID}'", "FILE_ID",
              fileIdentifier);
        return -1;
    }

    int original_fd = fileno(original_fp);
    if (original_fd == -1)
    {
        error(
            "Failed to get file descriptor for file pointer for file identifier '{FILE_ID}'",
            "FILE_ID", fileIdentifier);
        return -1;
    }

    int duplicated_fd = dup(original_fd);
    if (duplicated_fd == -1)
    {
        error(
            "Failed to duplicate file descriptor for file identifier '{FILE_ID}'",
            "FILE_ID", fileIdentifier);
        return -1;
    }

    // TODO: the mode should match the original mode. For now read only is
    // supported.
    FILE* duplicated_fp = fdopen(duplicated_fd, "rb");
    if (!duplicated_fp)
    {
        close(duplicated_fd);
        error("Failed to open file descriptor for file identifier '{FILE_ID}'",
              "FILE_ID", fileIdentifier);
        return -1;
    }

    *fp = duplicated_fp;
    *fileSize = it->second.fileSize;

    return 0;
}
} // namespace platform
} // namespace responder
} // namespace pldm