/*
// Copyright (c) 2018 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/
#pragma once

#include "app.hpp"
#include "dbus_utility.hpp"
#include "error_messages.hpp"
#include "external_storer.hpp"
#include "health.hpp"
#include "managed_store.hpp"
#include "managed_store_types.hpp"
#include "query.hpp"
#include "registries/privilege_registry.hpp"
#include "utils/collection.hpp"
#include "utils/dbus_utils.hpp"
#include "utils/hex_utils.hpp"
#include "utils/json_utils.hpp"
#include "utils/location_utils.hpp"
#include "utils/system_utils.hpp"

#include <boost/container/flat_map.hpp>
#include <boost/system/error_code.hpp>
#include <sdbusplus/asio/property.hpp>
#include <sdbusplus/message/native_types.hpp>
#include <sdbusplus/unpack_properties.hpp>
#include <sdbusplus/utility/dedup_variant.hpp>

#include <algorithm>
#include <array>
#include <cstdint>
#include <limits>
#include <string_view>
#include <unordered_map>

#ifdef UNIT_TEST_BUILD
#include "test/g3/mock_managed_store.hpp" // NOLINT
#endif

namespace redfish
{

using resourceIdToSubtreeRespMapType =
    std::unordered_map<std::string,
                       std::pair<std::string, dbus::utility::MapperServiceMap>>;
using ManagedObjectByServiceMap =
    std::unordered_map<std::string, dbus::utility::ManagedObjectType>;

constexpr std::array<std::string_view, 2> processorInterfaces = {
    "xyz.openbmc_project.Inventory.Item.Cpu",
    "xyz.openbmc_project.Inventory.Item.Accelerator"};

constexpr std::array<std::string_view, 1> subProcessorCoreInterfaces = {
    "xyz.openbmc_project.Inventory.Item.CpuCore"};

constexpr std::array<std::string_view, 1> subProcessorThreadInterfaces = {
    "xyz.openbmc_project.Inventory.Item.CpuThread"};

inline void getSubProcessorThreadCollectionWithExpand(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const nlohmann::json::json_pointer& jsonPtr, uint8_t expandLevel,
    const std::string& processorId, const std::string& coreId,
    const std::string& corePath,
    const dbus::utility::MapperGetSubTreeResponse& subtree,
    const ManagedObjectByServiceMap& managedObjectsMap);

inline void getSubProcessorCoreCollectionWithExpand(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const nlohmann::json::json_pointer& jsonPtr, uint8_t expandLevel,
    const std::string& processorId, const std::string& cpuPath,
    const dbus::utility::MapperGetSubTreeResponse& subtree,
    const ManagedObjectByServiceMap& managedObjectsMap);

inline void getProcessorCollectionWithExpand(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const dbus::utility::MapperGetSubTreeResponse& subtree,
    const ManagedObjectByServiceMap& managedObjectsMap, uint8_t expandLevel,
    const std::string& systempath);

inline void handleGetCpuCoreThreadMetrics(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const nlohmann::json::json_pointer& jsonPtr, const std::string& cpuArg,
    const std::string& coreArg, const std::string& threadArg);

inline void
    handleGetCpuMetrics(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                        const nlohmann::json::json_pointer& jsonPtr,
                        const std::string& cpuArg);

/**
 * @brief Returns a collection of dbus interfaces applicable to SubProcessor's
 * subtree.
 *
 * @param[in] expandLevel Requested expand level.
 *
 * @return Vector of strings capturing dbus interface names.
 */
inline std::vector<std::string>
    getInterfacesForSubProcessorSubtree(uint8_t expandLevel)
{
    std::vector<std::string> subProcessorSubtreeInterfaces = {
        subProcessorCoreInterfaces.begin(), subProcessorCoreInterfaces.end()};
    if (expandLevel > 0)
    {
        subProcessorSubtreeInterfaces.insert(
            subProcessorSubtreeInterfaces.end(),
            subProcessorThreadInterfaces.begin(),
            subProcessorThreadInterfaces.end());
        return subProcessorSubtreeInterfaces;
    }
    return subProcessorSubtreeInterfaces;
}

/**
 * @brief Returns a collection of dbus interfaces applicable to Processor's
 * subtree.
 *
 * @param[in] expandLevel Requested expand level.
 *
 * @return Vector of strings capturing dbus interface names.
 */
inline std::vector<std::string>
    getInterfacesForProcessorSubtree(uint8_t expandLevel)
{
    if (expandLevel > 0)
    {
        std::vector<std::string> processorSubtreeInterfaces =
            getInterfacesForSubProcessorSubtree(expandLevel - 1);
        processorSubtreeInterfaces.insert(processorSubtreeInterfaces.end(),
                                          processorInterfaces.begin(),
                                          processorInterfaces.end());
        return processorSubtreeInterfaces;
    }
    return {processorInterfaces.begin(), processorInterfaces.end()};
}

/**
 * @brief Fill out uuid info of a processor by
 * requesting data from the given D-Bus object.
 *
 * @param[in,out]   aResp           Async HTTP response.
 * @param[in]       objPath         D-Bus object to query.
 * @param[in]       interface       D-Bus interface to query.
 * @param[in]       jsonPtr         json pointer to index the response fields
 * @param[in]       managedObjects  Dbus objects with interfaces and properties.
 */
inline void
    getProcessorUUID(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                     const std::string& objPath, const std::string& interface,
                     const nlohmann::json::json_pointer& jsonPtr,
                     const dbus::utility::ManagedObjectType& managedObjects)
{
    BMCWEB_LOG_DEBUG << "Get Processor UUID";
    dbus::utility::DBusPropertiesMap properties;
    dbus_utils::getPropertiesFromManagedObjects(managedObjects, objPath,
                                                interface, properties);

    const std::string* property = nullptr;

    const bool success = sdbusplus::unpackPropertiesNoThrow(
        dbus_utils::UnpackErrorPrinter(), properties, "UUID", property);

    if (!success)
    {
        messages::internalError(aResp->res);
        return;
    }

    if (property != nullptr)
    {
        aResp->res.jsonValue[jsonPtr]["UUID"] = *property;
    }
}

/**
 * @brief Populates Cpu information using given dbus properties.
 *
 * @param[in] aResp             Async HTTP response.
 * @param[in] jsonPtr           json pointer to index the response fields.
 * @param[in] dbusProperties    DBusPropertiesMap to parse for Cpu data.
 *
 * @return void
 */
inline void getCpuDataFromDbusProperties(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const nlohmann::json::json_pointer& jsonPtr,
    const dbus::utility::DBusPropertiesMap& dbusProperties)
{
    BMCWEB_LOG_DEBUG << "Get CPU resources from dbus properties.";

    // Set the default value of state
    aResp->res.jsonValue[jsonPtr]["Status"]["State"] = "Enabled";
    aResp->res.jsonValue[jsonPtr]["Status"]["Health"] = "OK";

    for (const auto& property : dbusProperties)
    {
        if (property.first == "Present")
        {
            const bool* cpuPresent = std::get_if<bool>(&property.second);
            if (cpuPresent == nullptr)
            {
                // Important property not in desired type
                messages::internalError(aResp->res);
                return;
            }
            if (!*cpuPresent)
            {
                // Slot is not populated
                aResp->res.jsonValue[jsonPtr]["Status"]["State"] = "Absent";
            }
        }
        else if (property.first == "Functional")
        {
            const bool* cpuFunctional = std::get_if<bool>(&property.second);
            if (cpuFunctional == nullptr)
            {
                messages::internalError(aResp->res);
                return;
            }
            if (!*cpuFunctional)
            {
                aResp->res.jsonValue[jsonPtr]["Status"]["Health"] = "Critical";
            }
        }
        else if (property.first == "CoreCount")
        {
            const uint16_t* coresCount =
                std::get_if<uint16_t>(&property.second);
            if (coresCount == nullptr)
            {
                messages::internalError(aResp->res);
                return;
            }
            aResp->res.jsonValue[jsonPtr]["TotalCores"] = *coresCount;
        }
        else if (property.first == "MaxSpeedInMhz")
        {
            const uint32_t* value = std::get_if<uint32_t>(&property.second);
            if (value != nullptr)
            {
                aResp->res.jsonValue[jsonPtr]["MaxSpeedMHz"] = *value;
            }
        }
        else if (property.first == "Socket")
        {
            const std::string* value =
                std::get_if<std::string>(&property.second);
            if (value != nullptr)
            {
                aResp->res.jsonValue[jsonPtr]["Socket"] = *value;
            }
        }
        else if (property.first == "ThreadCount")
        {
            const uint16_t* value = std::get_if<uint16_t>(&property.second);
            if (value != nullptr)
            {
                aResp->res.jsonValue[jsonPtr]["TotalThreads"] = *value;
            }
        }
        else if (property.first == "CoreEnable")
        {
            const uint16_t* value = std::get_if<uint16_t>(&property.second);
            if (value != nullptr)
            {
                aResp->res.jsonValue[jsonPtr]["TotalEnabledCores"] = *value;
            }
        }
        else if (property.first == "EffectiveFamily")
        {
            const uint16_t* value = std::get_if<uint16_t>(&property.second);
            if (value != nullptr && *value != 2)
            {
                aResp->res
                    .jsonValue[jsonPtr]["ProcessorId"]["EffectiveFamily"] =
                    "0x" + intToHexString(*value, 4);
            }
        }
        else if (property.first == "EffectiveModel")
        {
            const uint16_t* value = std::get_if<uint16_t>(&property.second);
            if (value == nullptr)
            {
                messages::internalError(aResp->res);
                return;
            }
            if (*value != 0)
            {
                aResp->res.jsonValue[jsonPtr]["ProcessorId"]["EffectiveModel"] =
                    "0x" + intToHexString(*value, 4);
            }
        }
        else if (property.first == "Id")
        {
            const uint64_t* value = std::get_if<uint64_t>(&property.second);
            if (value != nullptr && *value != 0)
            {
                aResp->res.jsonValue[jsonPtr]["ProcessorId"]
                                    ["IdentificationRegisters"] =
                    "0x" + intToHexString(*value, 16);
            }
        }
        else if (property.first == "Microcode")
        {
            const uint32_t* value = std::get_if<uint32_t>(&property.second);
            if (value == nullptr)
            {
                messages::internalError(aResp->res);
                return;
            }
            if (*value != 0)
            {
                aResp->res.jsonValue[jsonPtr]["ProcessorId"]["MicrocodeInfo"] =
                    "0x" + intToHexString(*value, 8);
            }
        }
        else if (property.first == "Step")
        {
            const uint16_t* value = std::get_if<uint16_t>(&property.second);
            if (value == nullptr)
            {
                messages::internalError(aResp->res);
                return;
            }
            if (*value != std::numeric_limits<uint16_t>::max())
            {
                aResp->res.jsonValue[jsonPtr]["ProcessorId"]["Step"] =
                    "0x" + intToHexString(*value, 4);
            }
        }
    }
}

/**
 * @brief Populates Cpu information using given dbus Managed Objects.
 *
 * @param[in] aResp         Async HTTP response.
 * @param[in] cpuId         Cpu identifier.
 * @param[in] objPath       Cpu dbus object path.
 * @param[in] interface     Cpu dbus interface name.
 * @param[in] jsonPtr       json pointer to index the response fields.
 * @param[in] dbusData      Dbus Managed Objects to parse for Cpu data.
 *
 * @return void
 */
inline void getCpuData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                       const std::string& cpuId, const std::string& objPath,
                       const std::string& interface,
                       const nlohmann::json::json_pointer& jsonPtr,
                       const dbus::utility::ManagedObjectType& dbusData)
{
    BMCWEB_LOG_DEBUG << "Get Cpu data from managed objects for object "
                     << objPath;
    aResp->res.jsonValue[jsonPtr]["Id"] = cpuId;
    aResp->res.jsonValue[jsonPtr]["Name"] = "Processor";
    aResp->res.jsonValue[jsonPtr]["ProcessorType"] = "CPU";

    bool slotPresent = false;
    std::string corePath = objPath + "/core";
    size_t totalCores = 0;
    for (const auto& object : dbusData)
    {
        dbus::utility::DBusPropertiesMap properties;
        if (object.first.str == objPath)
        {
            dbus_utils::getPropertiesFromManagedObjects(dbusData, objPath,
                                                        interface, properties);
            getCpuDataFromDbusProperties(aResp, jsonPtr, properties);
        }
        else if (object.first.str.starts_with(corePath))
        {
            dbus_utils::getPropertiesFromManagedObjects(
                dbusData, object.first.str,
                "xyz.openbmc_project.Inventory.Item", properties);

            for (const auto& property : properties)
            {
                if (property.first != "Present")
                {
                    continue;
                }
                const bool* present = std::get_if<bool>(&property.second);
                if (present != nullptr && *present)
                {
                    slotPresent = true;
                    totalCores++;
                }
            }
        }
    }
    // In getCpuDataFromDbusProperties(), state and health are set based on the
    // present and functional status. If core count is zero, then it has a
    // higher precedence.
    if (slotPresent)
    {
        if (totalCores == 0)
        {
            // Slot is not populated, set status end return
            aResp->res.jsonValue[jsonPtr]["Status"]["State"] = "Absent";
            aResp->res.jsonValue[jsonPtr]["Status"]["Health"] = "OK";
        }
        aResp->res.jsonValue[jsonPtr]["TotalCores"] = totalCores;
    }
}

/**
 * @brief Populates Cpu asset information using given dbus Managed Objects.
 *
 * @param[in] aResp             Async HTTP response.
 * @param[in] objPath           Cpu dbus object path.
 * @param[in] interface         Cpu dbus interface name.
 * @param[in] jsonPtr           json pointer to index the response fields.
 * @param[in] managedObjects    Dbus Managed Objects to parse for Cpu data.
 *
 * @return void
 */
inline void
    getCpuAssetData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                    const std::string& objPath, const std::string& interface,
                    const nlohmann::json::json_pointer& jsonPtr,
                    const dbus::utility::ManagedObjectType& managedObjects)
{
    BMCWEB_LOG_DEBUG << "Get Cpu Asset Data";
    const std::string* serialNumber = nullptr;
    const std::string* model = nullptr;
    const std::string* manufacturer = nullptr;
    const std::string* partNumber = nullptr;
    const std::string* sparePartNumber = nullptr;

    dbus::utility::DBusPropertiesMap properties;
    dbus_utils::getPropertiesFromManagedObjects(managedObjects, objPath,
                                                interface, properties);

    const bool success = sdbusplus::unpackPropertiesNoThrow(
        dbus_utils::UnpackErrorPrinter(), properties, "SerialNumber",
        serialNumber, "Model", model, "Manufacturer", manufacturer,
        "PartNumber", partNumber, "SparePartNumber", sparePartNumber);

    if (!success)
    {
        messages::internalError(aResp->res);
        return;
    }

    if (serialNumber != nullptr && !serialNumber->empty())
    {
        aResp->res.jsonValue[jsonPtr]["SerialNumber"] = *serialNumber;
    }

    if ((model != nullptr) && !model->empty())
    {
        aResp->res.jsonValue[jsonPtr]["Model"] = *model;
    }

    if (manufacturer != nullptr)
    {
        aResp->res.jsonValue[jsonPtr]["Manufacturer"] = *manufacturer;

        // Otherwise would be unexpected.
        if (manufacturer->find("Intel") != std::string::npos)
        {
            aResp->res.jsonValue[jsonPtr]["ProcessorArchitecture"] = "x86";
            aResp->res.jsonValue[jsonPtr]["InstructionSet"] = "x86-64";
        }
        else if (manufacturer->find("IBM") != std::string::npos)
        {
            aResp->res.jsonValue[jsonPtr]["ProcessorArchitecture"] = "Power";
            aResp->res.jsonValue[jsonPtr]["InstructionSet"] = "PowerISA";
        }
    }

    if (partNumber != nullptr)
    {
        aResp->res.jsonValue[jsonPtr]["PartNumber"] = *partNumber;
    }

    if (sparePartNumber != nullptr && !sparePartNumber->empty())
    {
        aResp->res.jsonValue[jsonPtr]["SparePartNumber"] = *sparePartNumber;
    }
}

/**
 * @brief Populates Cpu revision data using given dbus Managed Objects.
 *
 * @param[in] aResp             Async HTTP response.
 * @param[in] objPath           Cpu dbus object path.
 * @param[in] interface         Cpu dbus interface name.
 * @param[in] jsonPtr           json pointer to index the response fields.
 * @param[in] managedObjects    Dbus Managed Objects to parse for Cpu data.
 *
 * @return void
 */
inline void
    getCpuRevisionData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                       const std::string& objPath, const std::string& interface,
                       const nlohmann::json::json_pointer& jsonPtr,
                       const dbus::utility::ManagedObjectType& managedObjects)
{
    BMCWEB_LOG_DEBUG << "Get Cpu Revision Data";
    dbus::utility::DBusPropertiesMap properties;
    dbus_utils::getPropertiesFromManagedObjects(managedObjects, objPath,
                                                interface, properties);

    const std::string* version = nullptr;

    const bool success = sdbusplus::unpackPropertiesNoThrow(
        dbus_utils::UnpackErrorPrinter(), properties, "Version", version);

    if (!success)
    {
        messages::internalError(aResp->res);
        return;
    }

    if (version != nullptr)
    {
        aResp->res.jsonValue[jsonPtr]["Version"] = *version;
    }
}

/**
 * @brief Populates accelerator data using given dbus Managed Objects.
 *
 * @param[in] aResp             Async HTTP response.
 * @param[in] acclrtrId         Accelerator identifier.
 * @param[in] objPath           Accelerator dbus object path.
 * @param[in] interface         Accelerator dbus interface name.
 * @param[in] jsonPtr           json pointer to index the response fields.
 * @param[in] managedObjects    Dbus Managed Objects to parse.
 *
 * @return void
 */
inline void
    getAcceleratorData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                       const std::string& acclrtrId, const std::string& objPath,
                       const std::string& interface,
                       const nlohmann::json::json_pointer& jsonPtr,
                       const dbus::utility::ManagedObjectType& managedObjects)
{
    BMCWEB_LOG_DEBUG
        << "Get available system Accelerator resources by service.";

    const bool* functional = nullptr;
    const bool* present = nullptr;

    dbus::utility::DBusPropertiesMap properties;
    dbus_utils::getPropertiesFromManagedObjects(managedObjects, objPath,
                                                interface, properties);

    const bool success = sdbusplus::unpackPropertiesNoThrow(
        dbus_utils::UnpackErrorPrinter(), properties, "Functional", functional,
        "Present", present);

    if (!success)
    {
        messages::internalError(aResp->res);
        return;
    }

    std::string state = "Enabled";
    std::string health = "OK";

    if (present != nullptr && !*present)
    {
        state = "Absent";
    }

    if (functional != nullptr && !*functional)
    {
        if (state == "Enabled")
        {
            health = "Critical";
        }
    }

    aResp->res.jsonValue[jsonPtr]["Id"] = acclrtrId;
    aResp->res.jsonValue[jsonPtr]["Name"] = "Processor";
    aResp->res.jsonValue[jsonPtr]["Status"]["State"] = state;
    aResp->res.jsonValue[jsonPtr]["Status"]["Health"] = health;
    aResp->res.jsonValue[jsonPtr]["ProcessorType"] = "Accelerator";
}

// OperatingConfig D-Bus Types
using TurboProfileProperty = std::vector<std::tuple<uint32_t, size_t>>;
using BaseSpeedPrioritySettingsProperty =
    std::vector<std::tuple<uint32_t, std::vector<uint32_t>>>;
// uint32_t and size_t may or may not be the same type, requiring a dedup'd
// variant

/**
 * Fill out the HighSpeedCoreIDs in a Processor resource from the given
 * OperatingConfig D-Bus property.
 *
 * @param[in,out]   aResp               Async HTTP response.
 * @param[in]       jsonPtr     json pointer to index the response fields
 * @param[in]       baseSpeedSettings   Full list of base speed priority groups,
 *                                      to use to determine the list of high
 *                                      speed cores.
 */
inline void highSpeedCoreIdsHandler(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const nlohmann::json::json_pointer& jsonPtr,
    const BaseSpeedPrioritySettingsProperty& baseSpeedSettings)
{
    // The D-Bus property does not indicate which bucket is the "high
    // priority" group, so let's discern that by looking for the one with
    // highest base frequency.
    auto highPriorityGroup = baseSpeedSettings.cend();
    uint32_t highestBaseSpeed = 0;
    for (auto it = baseSpeedSettings.cbegin(); it != baseSpeedSettings.cend();
         ++it)
    {
        const uint32_t baseFreq = std::get<uint32_t>(*it);
        if (baseFreq > highestBaseSpeed)
        {
            highestBaseSpeed = baseFreq;
            highPriorityGroup = it;
        }
    }

    nlohmann::json& jsonCoreIds =
        aResp->res.jsonValue[jsonPtr]["HighSpeedCoreIDs"];
    jsonCoreIds = nlohmann::json::array();

    // There may not be any entries in the D-Bus property, so only populate
    // if there was actually something there.
    if (highPriorityGroup != baseSpeedSettings.cend())
    {
        jsonCoreIds = std::get<std::vector<uint32_t>>(*highPriorityGroup);
    }
}

/**
 * Fill out OperatingConfig related items in a Processor resource by requesting
 * data from the given D-Bus object.
 *
 * @param[in,out]   aResp           Async HTTP response.
 * @param[in]       cpuId           CPU D-Bus name.
 * @param[in]       objPath         D-Bus object to query.
 * @param[in]       interface       D-Bus interface to query.
 * @param[in]       jsonPtr         json pointer to index the response fields
 * @param[in]       managedObjects  Dbus objects with interfaces and properties.
 */
inline void
    getCpuConfigData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                     const std::string& cpuId, const std::string& objPath,
                     const std::string& interface,
                     const nlohmann::json::json_pointer& jsonPtr,
                     const dbus::utility::ManagedObjectType& managedObjects)
{
    BMCWEB_LOG_INFO << "Getting CPU operating configs for " << cpuId;

    nlohmann::json& json = aResp->res.jsonValue;

    const sdbusplus::message::object_path* appliedConfig = nullptr;
    const bool* baseSpeedPriorityEnabled = nullptr;
    const BaseSpeedPrioritySettingsProperty* baseSpeedList = nullptr;

    dbus::utility::DBusPropertiesMap properties;
    dbus_utils::getPropertiesFromManagedObjects(managedObjects, objPath,
                                                interface, properties);

    const bool success = sdbusplus::unpackPropertiesNoThrow(
        dbus_utils::UnpackErrorPrinter(), properties, "AppliedConfig",
        appliedConfig, "BaseSpeedPriorityEnabled", baseSpeedPriorityEnabled);

    if (!success)
    {
        messages::internalError(aResp->res);
        return;
    }

    if (appliedConfig != nullptr)
    {
        const std::string& dbusPath = appliedConfig->str;
        std::string uri = "/redfish/v1/Systems/system/Processors/" + cpuId +
                          "/OperatingConfigs";
        nlohmann::json::object_t operatingConfig;
        operatingConfig["@odata.id"] = uri;
        json[jsonPtr]["OperatingConfigs"] = std::move(operatingConfig);

        // Reuse the D-Bus config object name for the Redfish
        // URI
        size_t baseNamePos = dbusPath.rfind('/');
        if (baseNamePos == std::string::npos ||
            baseNamePos == (dbusPath.size() - 1))
        {
            // If the AppliedConfig was somehow not a valid path,
            // skip adding any more properties, since everything
            // else is tied to this applied config.
            messages::internalError(aResp->res);
            return;
        }
        uri += '/';
        uri += dbusPath.substr(baseNamePos + 1);
        nlohmann::json::object_t appliedOperatingConfig;
        appliedOperatingConfig["@odata.id"] = uri;
        json[jsonPtr]["AppliedOperatingConfig"] =
            std::move(appliedOperatingConfig);

        // Once we found the current applied config, read the base freq core ids
        // out of Operating config.

        dbus::utility::DBusPropertiesMap config;
        dbus_utils::getPropertiesFromManagedObjects(
            managedObjects, dbusPath,
            "xyz.openbmc_project.Inventory.Item.Cpu.OperatingConfig", config);

        const bool parseConfigSuccess = sdbusplus::unpackPropertiesNoThrow(
            dbus_utils::UnpackErrorPrinter(), config,
            "BaseSpeedPrioritySettings", baseSpeedList);

        if (!parseConfigSuccess)
        {
            messages::internalError(aResp->res);
            return;
        }

        if (baseSpeedList != nullptr)
        {
            highSpeedCoreIdsHandler(aResp, jsonPtr, *baseSpeedList);
        }
    }

    if (baseSpeedPriorityEnabled != nullptr)
    {
        json[jsonPtr]["BaseSpeedPriorityState"] =
            *baseSpeedPriorityEnabled ? "Enabled" : "Disabled";
    }
}

/**
 * Populate the unique identifier in a Processor resource by requesting data
 * from the given D-Bus object.
 *
 * @param[in,out]   aResp           Async HTTP response.
 * @param[in]       objPath         D-Bus object to query.
 * @param[in]       interface       D-Bus interface to query.
 * @param[in]       jsonPtr         json pointer to index the response fields
 * @param[in]       managedObjects  Dbus objects with interfaces and properties.
 */
inline void
    getCpuUniqueId(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                   const std::string& objectPath, const std::string& interface,
                   const nlohmann::json::json_pointer& jsonPtr,
                   const dbus::utility::ManagedObjectType& managedObjects)
{
    BMCWEB_LOG_DEBUG << "Get CPU UniqueIdentifier";
    dbus::utility::DBusPropertiesMap properties;
    dbus_utils::getPropertiesFromManagedObjects(managedObjects, objectPath,
                                                interface, properties);

    const std::string* id = nullptr;

    const bool success = sdbusplus::unpackPropertiesNoThrow(
        dbus_utils::UnpackErrorPrinter(), properties, "UniqueIdentifier", id);

    if (!success)
    {
        messages::internalError(aResp->res);
        return;
    }

    if (id != nullptr)
    {
        aResp->res.jsonValue[jsonPtr]["ProcessorId"]
                            ["ProtectedIdentificationNumber"] = *id;
    }
}

inline void getCpuChassisAssociation(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& processorId, const std::string& objectPath,
    const nlohmann::json::json_pointer& jsonPtr)
{
    BMCWEB_LOG_DEBUG << "Get CPU -- Chassis association";

    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    dbus_utils::getProperty<std::vector<std::string>>(
        "xyz.openbmc_project.ObjectMapper", objectPath + "/chassis",
        "xyz.openbmc_project.Association", "endpoints", requestContext,
        [asyncResp{asyncResp}, jsonPtr,
         processorId](const boost::system::error_code ec,
                      const std::vector<std::string>& chassisList) {
        if (ec)
        {
            return;
        }
        if (chassisList.empty())
        {
            return;
        }
        if (chassisList.size() > 1)
        {
            BMCWEB_LOG_DEBUG << processorId
                             << " is associated with mutliple chassis";
            return;
        }

        sdbusplus::message::object_path chassisPath(chassisList[0]);
        std::string chassisName = chassisPath.filename();
        if (chassisName.empty())
        {
            BMCWEB_LOG_ERROR << "filename() is empty in " << chassisPath.str;
            return;
        }
        asyncResp->res.jsonValue[jsonPtr]["Links"]["Chassis"] = {
            {"@odata.id", "/redfish/v1/Chassis/" + chassisName}};
    });
}

/**
 * @brief Fill out the links to associated memory of a processor
 * by looking up its D-Bus association.
 *
 * @param[in,out]   aResp       Async HTTP response.
 * @param[in]       objPath     D-Bus object to query.
 */
inline void getMemoryLinks(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                           const std::string& objectPath,
                           const nlohmann::json::json_pointer& jsonPtr)
{
    BMCWEB_LOG_DEBUG << "Get Processor -- Memory association";

    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    dbus_utils::getProperty<std::vector<std::string>>(
        "xyz.openbmc_project.ObjectMapper", objectPath + "/memory",
        "xyz.openbmc_project.Association", "endpoints", requestContext,
        [asyncResp, jsonPtr](const boost::system::error_code ec,
                             const std::vector<std::string>& memoryList) {
        if (ec)
        {
            return;
        }
        if (memoryList.empty())
        {
            return;
        }
        nlohmann::json::array_t memoryLinks;
        for (const std::string& memory : memoryList)
        {
            sdbusplus::message::object_path memoryPath(memory);
            const std::string memoryName = memoryPath.filename();
            if (memoryName.empty())
            {
                BMCWEB_LOG_ERROR << "filename() is empty in " << memoryPath.str;
                return;
            }
            nlohmann::json::object_t memoryObject;
            memoryObject["@odata.id"] =
                "/redfish/v1/Systems/system/Memory/" + memoryName;
            memoryLinks.emplace_back(memoryObject);
        }
        asyncResp->res.jsonValue[jsonPtr]["Links"]["Memory"] =
            std::move(memoryLinks);
    });
}

/**
 * Find the D-Bus object representing the requested Processor, and call the
 * handler with the results. If matching object is not found, add 404 error to
 * response and don't call the handler.
 *
 * @param[in,out]   resp            Async HTTP response.
 * @param[in]       processorId     Redfish Processor Id.
 * @param[in]       handler         Callback to continue processing request upon
 *                                  successfully finding object.
 */
template <typename Handler>
inline void getProcessorObject(const std::shared_ptr<bmcweb::AsyncResp>& resp,
                               const std::string& processorId,
                               const std::string& systemPath, Handler&& handler)
{
    BMCWEB_LOG_DEBUG << "Get available system processor resources.";

    const bool multiHost = !systemPath.empty();

    // Default systemName is system and change if system is multi-host
    std::string systemName = "system";
    // The subtree to query for Dimms changes if single or multi-host
    std::string subtreeRoot = "/xyz/openbmc_project/inventory";

    if (multiHost)
    {
        systemName = sdbusplus::message::object_path(systemPath).filename();
        subtreeRoot = systemPath;
    }

    managedStore::ManagedObjectStoreContext context(resp);
    managedStore::GetManagedObjectStore()->getSubTree(
        subtreeRoot, 0, processorInterfaces, context,
        [resp{resp}, processorId, multiHost, systemPath,
         handler = std::forward<Handler>(handler), context](
            const boost::system::error_code& ec,
            const dbus::utility::MapperGetSubTreeResponse& subtree) mutable {
        if (ec)
        {
            BMCWEB_LOG_ERROR << "DBUS response error: " << ec.value();
            messages::internalError(resp->res);
            return;
        }

        std::vector<std::string> serviceNames =
            dbus_utils::getServiceNamesFromSubtree(subtree);
        if (serviceNames.empty())
        {
            BMCWEB_LOG_ERROR << "Service list is empty";
            messages::internalError(resp->res);
            return;
        }

        sdbusplus::message::object_path path("/xyz/openbmc_project/inventory");
        dbus_utils::getManagedObjectsInEachService(
            std::move(serviceNames), path, context,
            [resp{std::move(resp)}, subtree, processorId, multiHost, systemPath,
             handler = std::forward<Handler>(handler)](
                const ManagedObjectByServiceMap& managedObjectsByService) {
            if (managedObjectsByService.empty())
            {
                BMCWEB_LOG_ERROR
                    << "GetManagedObjects does not return any object.";
                messages::internalError(resp->res);
                return;
            }
            BMCWEB_LOG_DEBUG << "Looping through subtree";

            for (const auto& [objectPath, serviceMap] : subtree)
            {
                BMCWEB_LOG_DEBUG << objectPath;
                if (multiHost && !objectPath.starts_with(systemPath))
                {
                    continue;
                }

                // Ignore any objects which don't end with our desired cpu name
                if (!objectPath.ends_with(processorId))
                {
                    continue;
                }

                // Filter out objects that don't have the CPU-specific
                // interfaces to make sure we can return 404 on non-CPUs
                // (e.g. /redfish/../Processors/dimm0)
                if (!dbus_utils::findInterfacesInServiceMap(
                        serviceMap, processorInterfaces))
                {
                    continue;
                }
                handler(objectPath, subtree, managedObjectsByService);
                return;
            }
            messages::resourceNotFound(resp->res, "Processor", processorId);
        });
    });
}

inline void
    getProcessorState(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                      const std::string& service, const std::string& objPath,
                      const nlohmann::json::json_pointer& jsonPtr)
{

    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    dbus_utils::getProperty<bool>(
        service, objPath, "xyz.openbmc_project.Inventory.Item", "Present",
        requestContext,
        [asyncResp, objPath, jsonPtr](const boost::system::error_code& ec,
                                      bool present) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "get presence failed for Processor State "
                             << objPath << " with error " << ec;

            if (ec.value() != EBADR)
            {
                messages::internalError(asyncResp->res);
            }
            return;
        }
        asyncResp->res.jsonValue[jsonPtr]["Status"]["State"] =
            present ? "Enabled" : "Absent";
    });
}

inline void getProcessorStateData(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& systemName, const std::string& processorId,
    const std::string& procStateId, const nlohmann::json::json_pointer& jsonPtr)
{
    BMCWEB_LOG_DEBUG << "Processor State Id: " << procStateId;
    asyncResp->res.jsonValue[jsonPtr]["@odata.id"] =
        crow::utility::urlFromPieces("redfish", "v1", "Systems", systemName,
                                     "Processors", processorId, "Oem", "Google",
                                     "ProcessorStates", procStateId);
    asyncResp->res.jsonValue[jsonPtr]["@odata.type"] =
        "#GoogleProcessorState.GoogleProcessorState";
    asyncResp->res.jsonValue[jsonPtr]["Id"] = procStateId;
    asyncResp->res.jsonValue[jsonPtr]["Name"] = "Processor";
    getProcessorState(asyncResp, "xyz.openbmc_project.EntityManager",
                      absl::StrCat("/xyz/openbmc_project/inventory/",
                                   systemName, "/processorstate/", procStateId),
                      jsonPtr);
}

void handleGetProcessorState(
    App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& systemName, const std::string& processorId,
    const std::string& procStateId)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }
    getProcessorStateData(asyncResp, systemName, processorId, procStateId,
                          ""_json_pointer);
}

using Mapper = dbus::utility::MapperGetSubTreePathsResponse;
inline void getProcessorStateLinksOrExpand(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& processorId, const nlohmann::json::json_pointer& jsonPtr,
    const std::string& systemName, uint8_t expandLevel,
    const boost::system::error_code& ec, const Mapper& procStatePaths)
{
    BMCWEB_LOG_DEBUG << "Get Processor State URL";

    if (ec)
    {
        BMCWEB_LOG_ERROR
            << "ProcessorState Collection GetSubTreePaths handler Dbus error "
            << ec;
        return;
    }
    nlohmann::json::array_t procStateLinks;
    size_t stateCount = 0;
    for (const std::string& procState : procStatePaths)
    {
        std::string procStateId =
            sdbusplus::message::object_path(procState).filename();
        nlohmann::json::json_pointer processorStatePtr =
            jsonPtr / "Oem" / "Google" / "ProcessorStates" / stateCount++;
        if (expandLevel > 0)
        {
            getProcessorStateData(aResp, systemName, processorId, procStateId,
                                  processorStatePtr);
        }
        else
        {
            nlohmann::json::object_t procStateObj;
            aResp->res.jsonValue[processorStatePtr]["@odata.id"] =
                crow::utility::urlFromPieces("redfish", "v1", "Systems",
                                             systemName, "Processors",
                                             processorId, "Oem", "Google",
                                             "ProcessorStates", procStateId);
        }
    }
}

inline void
    getProcessorData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                     const nlohmann::json::json_pointer& jsonPtr,
                     uint8_t expandLevel, const std::string& processorId,
                     const std::string& systemPath,
                     const std::string& objectPath,
                     const dbus::utility::MapperGetSubTreeResponse& subtree,
                     const ManagedObjectByServiceMap& managedObjectsMap)
{
    BMCWEB_LOG_DEBUG << "Get processor data.";

    const bool multiHost = !systemPath.empty();

    // Default systemName is system and change if system is multi-host
    std::string systemName = "system";

    if (multiHost)
    {
        systemName = sdbusplus::message::object_path(systemPath).filename();
    }

    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/Processor/Processor.json>; rel=describedby");
    aResp->res.jsonValue[jsonPtr]["@odata.type"] =
        "#Processor.v1_11_0.Processor";
    aResp->res.jsonValue[jsonPtr]["@odata.id"] = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", systemName, "Processors", processorId);

    // Get service to interface map for cpu
    dbus::utility::MapperServiceMap serviceMap;
    for (const auto& [parsedObjectPath, parsedServiceMap] : subtree)
    {
        if (objectPath == parsedObjectPath)
        {
            serviceMap = parsedServiceMap;
            break;
        }
    }

    for (const auto& [serviceName, interfaceList] : serviceMap)
    {
        auto iter = managedObjectsMap.find(serviceName);
        if (iter == managedObjectsMap.end())
        {
            BMCWEB_LOG_DEBUG << "Cpu data not available for serviceName "
                             << serviceName;
            continue;
        }

        BMCWEB_LOG_DEBUG << "Populate processor data from dbus interfaces.";
        for (const auto& interface : interfaceList)
        {
            if (interface == "xyz.openbmc_project.Inventory.Decorator.Asset")
            {
                getCpuAssetData(aResp, objectPath, interface, jsonPtr,
                                iter->second);
            }
            else if (interface ==
                     "xyz.openbmc_project.Inventory.Decorator.Revision")
            {
                getCpuRevisionData(aResp, objectPath, interface, jsonPtr,
                                   iter->second);
            }
            else if (interface == "xyz.openbmc_project.Inventory.Item.Cpu")
            {
                getCpuData(aResp, processorId, objectPath, interface, jsonPtr,
                           iter->second);
            }
            else if (interface ==
                     "xyz.openbmc_project.Inventory.Item.Accelerator")
            {
                getAcceleratorData(aResp, processorId, objectPath, interface,
                                   jsonPtr, iter->second);
            }
            else if (
                interface ==
                "xyz.openbmc_project.Control.Processor.CurrentOperatingConfig")
            {
                getCpuConfigData(aResp, processorId, objectPath, interface,
                                 jsonPtr, iter->second);
            }
            else if (interface ==
                     "xyz.openbmc_project.Inventory.Decorator.LocationCode")
            {
                location_util::getLocationCodeFromManagedObject(
                    aResp, objectPath, interface, jsonPtr / "Location",
                    iter->second);
                location_util::getPartLocationContext(
                    aResp, jsonPtr / "Location", objectPath + "/chassis");
            }
            else if (interface == "xyz.openbmc_project.Common.UUID")
            {
                getProcessorUUID(aResp, objectPath, interface, jsonPtr,
                                 iter->second);
            }
            else if (interface ==
                     "xyz.openbmc_project.Inventory.Decorator.UniqueIdentifier")
            {
                getCpuUniqueId(aResp, objectPath, interface, jsonPtr,
                               iter->second);
            }
            else
            {
                std::optional<std::string> locationType =
                    location_util::getLocationType(interface);
                if (locationType == std::nullopt)
                {
                    BMCWEB_LOG_DEBUG
                        << "getLocationType for Processor failed for "
                        << interface;
                    continue;
                }

                aResp->res.jsonValue[jsonPtr]["Location"]["PartLocation"]
                                    ["LocationType"] = *locationType;
            }
        }
    }
    getCpuChassisAssociation(aResp, processorId, objectPath, jsonPtr);
    getMemoryLinks(aResp, objectPath, jsonPtr);

    managedStore::ManagedObjectStoreContext context(aResp);
    constexpr std::array<std::string_view, 1> procStateIntf = {
        "xyz.openbmc_project.Inventory.Item.ProcessorState"};
    dbus_utils::getSubTreePaths(
        "/xyz/openbmc_project/inventory", 0, procStateIntf, context,
        std::bind_front(getProcessorStateLinksOrExpand, aResp, processorId,
                        jsonPtr, systemName, expandLevel));

    // TODO(edward): Support SubProcessors and ProcessorMetrics for Multi-Host
    // as use-cases arise
    if (!multiHost)
    {
        if (expandLevel > 0)
        {
            nlohmann::json::json_pointer subProcessorPtr =
                jsonPtr / "SubProcessors";
            getSubProcessorCoreCollectionWithExpand(
                aResp, subProcessorPtr, expandLevel - 1, processorId,
                objectPath, subtree, managedObjectsMap);
        }
        else
        {
            aResp->res.jsonValue[jsonPtr]["SubProcessors"]["@odata.id"] =
                crow::utility::urlFromPieces("redfish", "v1", "Systems",
                                             "system", "Processors",
                                             processorId, "SubProcessors");
        }

        if (expandLevel > 0)
        {
            nlohmann::json::json_pointer metricsPtr = jsonPtr / "Metrics";
            handleGetCpuMetrics(aResp, metricsPtr, processorId);
        }
        else
        {
            // Inserting the "Metrics" JSON stanza
            std::string metricsUrl = aResp->res.jsonValue[jsonPtr]["@odata.id"];
            metricsUrl += "/ProcessorMetrics";
            nlohmann::json::object_t metricsObj;
            metricsObj["@odata.id"] = std::move(metricsUrl);
            aResp->res.jsonValue[jsonPtr]["Metrics"] = std::move(metricsObj);
        }
    }
}

template <typename Handler>
inline void getProcessorPaths(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                              const std::string& processorId, Handler&& handler)
{
    std::array<std::string_view, 1> interfaces{
        "xyz.openbmc_project.Inventory.Item.Cpu"};

    managedStore::ManagedObjectStoreContext requestContext(aResp);
    managedStore::GetManagedObjectStore()->getSubTreePaths(
        "/xyz/openbmc_project/inventory", 0, interfaces, requestContext,
        [processorId, aResp{aResp},
         handler{std::forward<Handler>(handler)}](
            const boost::system::error_code ec,
            const std::vector<std::string>& subTreePaths) {
        if (ec)
        {
            handler(ec, "");
            return;
        }

        for (const std::string& cpuPath : subTreePaths)
        {
            if (sdbusplus::message::object_path(cpuPath).filename() !=
                processorId)
            {
                continue;
            }

            handler(ec, cpuPath);
            return;
        }

        // Set an error code since valid cpu path is not found
        handler(boost::system::errc::make_error_code(
                    boost::system::errc::no_such_file_or_directory),
                "");
    });
}

template <typename Handler>
inline void
    getSubProcessorCorePaths(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                             const std::string& processorId,
                             const std::string& coreId, Handler&& handler)
{

    std::array<std::string_view, 1> interfaces{
        "xyz.openbmc_project.Inventory.Item.Cpu"};
    managedStore::ManagedObjectStoreContext requestContext(aResp);
    managedStore::GetManagedObjectStore()->getSubTreePaths(
        "/xyz/openbmc_project/inventory", 0, interfaces, requestContext,
        [processorId, coreId, aResp{aResp},
         handler{std::forward<Handler>(handler)},
         requestContext](const boost::system::error_code ec,
                         const std::vector<std::string>& subTreeCpuPaths) {
        if (ec)
        {
            handler(ec, "");
            return;
        }

        for (const std::string& cpuPath : subTreeCpuPaths)
        {
            if (sdbusplus::message::object_path(cpuPath).filename() !=
                processorId)
            {
                continue;
            }

            std::array<std::string_view, 1> interfaces{
                "xyz.openbmc_project.Inventory.Item.CpuCore"};
            managedStore::GetManagedObjectStore()->getSubTreePaths(
                "/xyz/openbmc_project/inventory", 0, interfaces, requestContext,
                [processorId, coreId, aResp{aResp},
                 handler](const boost::system::error_code ec2,
                          const std::vector<std::string>& subTreeCorePaths) {
                if (ec2)
                {
                    handler(ec2, "");
                    return;
                }

                for (const std::string& corePath : subTreeCorePaths)
                {
                    if (sdbusplus::message::object_path(corePath).filename() !=
                        coreId)
                    {
                        continue;
                    }
                    handler(ec2, corePath);
                    return;
                }
                // Set an error code since valid processor core path is not
                // found
                handler(boost::system::errc::make_error_code(
                            boost::system::errc::no_such_file_or_directory),
                        "");
            });
            return;
        }

        // Set an error code since valid processor cpu path is not found
        handler(boost::system::errc::make_error_code(
                    boost::system::errc::no_such_file_or_directory),
                "");
    });
}

inline void
    getCoreThreadData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                      const nlohmann::json::json_pointer& jsonPtr,
                      [[maybe_unused]] const uint8_t expandLevel,
                      const std::string& processorId, const std::string& coreId,
                      const std::string& threadId,
                      const std::string& threadPath,
                      const dbus::utility::MapperGetSubTreeResponse& subtree,
                      const ManagedObjectByServiceMap& managedObjectsMap)
{
    aResp->res.jsonValue[jsonPtr]["@odata.type"] =
        "#Processor.v1_11_0.Processor";
    aResp->res.jsonValue[jsonPtr]["@odata.id"] = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", "system", "Processors", processorId,
        "SubProcessors", coreId, "SubProcessors", threadId);
    aResp->res.jsonValue[jsonPtr]["Name"] = "SubProcessor";
    aResp->res.jsonValue[jsonPtr]["ProcessorType"] = "Thread";
    aResp->res.jsonValue[jsonPtr]["Id"] = threadId;

    aResp->res.jsonValue[jsonPtr]["Status"]["State"] = "Enabled";
    aResp->res.jsonValue[jsonPtr]["Status"]["Health"] = "OK";

    bool present = false;
    bool functional = false;

    dbus::utility::MapperServiceMap serviceMap;
    for (const auto& [parsedObjectPath, parsedServiceMap] : subtree)
    {
        if (threadPath == parsedObjectPath)
        {
            serviceMap = parsedServiceMap;
            break;
        }
    }

    for (const auto& [serviceName, interfaceList] : serviceMap)
    {
        auto iter = managedObjectsMap.find(serviceName);
        if (iter == managedObjectsMap.end())
        {
            BMCWEB_LOG_DEBUG << "Thread data not available for serviceName "
                             << serviceName;
            continue;
        }

        for (const auto& interface : interfaceList)
        {
            dbus::utility::DBusPropertiesMap properties;
            if (interface == "xyz.openbmc_project.State."
                             "Decorator.OperationalStatus")
            {
                const bool* propertyFunctional = nullptr;
                dbus_utils::getPropertiesFromManagedObjects(
                    iter->second, threadPath, interface, properties);
                const bool success = sdbusplus::unpackPropertiesNoThrow(
                    dbus_utils::UnpackErrorPrinter(), properties, "Functional",
                    propertyFunctional);
                if (!success || propertyFunctional == nullptr)
                {
                    continue;
                }
                functional = *propertyFunctional;
            }
            else if (interface == "xyz.openbmc_project.Inventory.Item")
            {
                const bool* propertyPresent = nullptr;
                const std::string* propertyPrettyName = nullptr;
                dbus_utils::getPropertiesFromManagedObjects(
                    iter->second, threadPath, interface, properties);
                const bool success = sdbusplus::unpackPropertiesNoThrow(
                    dbus_utils::UnpackErrorPrinter(), properties, "Present",
                    propertyPresent, "PrettyName", propertyPrettyName);
                if (!success)
                {
                    continue;
                }

                if (propertyPresent != nullptr)
                {
                    present = *propertyPresent;
                }

                if (propertyPrettyName != nullptr)
                {
                    aResp->res.jsonValue[jsonPtr]["Name"] = *propertyPrettyName;
                }
            }
            else if (interface ==
                     "xyz.openbmc_project.Inventory.Item.CpuThread")
            {
                const uint32_t* propertyMicrocode = nullptr;
                dbus_utils::getPropertiesFromManagedObjects(
                    iter->second, threadPath, interface, properties);
                const bool success = sdbusplus::unpackPropertiesNoThrow(
                    dbus_utils::UnpackErrorPrinter(), properties, "Microcode",
                    propertyMicrocode);
                if (!success)
                {
                    continue;
                }

                if (propertyMicrocode != nullptr)
                {
                    aResp->res
                        .jsonValue[jsonPtr]["ProcessorId"]["MicrocodeInfo"] =
                        "0x" + intToHexString(*propertyMicrocode, 8);
                }
            }
        }
    }

    if (!present)
    {
        aResp->res.jsonValue[jsonPtr]["Status"]["State"] = "Absent";
    }

    if (!functional)
    {
        aResp->res.jsonValue[jsonPtr]["Status"]["Health"] = "Critical";
    }

    if (expandLevel > 0)
    {
        nlohmann::json::json_pointer metricsPtr = jsonPtr / "Metrics";
        handleGetCpuCoreThreadMetrics(aResp, metricsPtr, processorId, coreId,
                                      threadId);
    }
    else
    {
        // Inserting the "Metrics" JSON stanza
        std::string metricsUrl = aResp->res.jsonValue[jsonPtr]["@odata.id"];
        metricsUrl += "/ProcessorMetrics";
        nlohmann::json::object_t metricsObj;
        metricsObj["@odata.id"] = std::move(metricsUrl);
        aResp->res.jsonValue[jsonPtr]["Metrics"] = std::move(metricsObj);
    }
}

inline void getSubProcessorThreadData(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& processorId, const std::string& coreId,
    const std::string& threadId, const boost::system::error_code ec,
    const std::string& corePath)
{
    if (ec)
    {
        BMCWEB_LOG_DEBUG << "DBUS response error, ec: " << ec.value();
        // No sub processor thread objects found by mapper
        if (ec.value() == boost::system::errc::io_error)
        {
            messages::resourceNotFound(aResp->res,
                                       "#Processor.v1_11_0.Processor", coreId);
            return;
        }

        messages::internalError(aResp->res);
        return;
    }
    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/Processor/Processor.json>; rel=describedby");

    managedStore::ManagedObjectStoreContext context(aResp);
    managedStore::GetManagedObjectStore()->getSubTree(
        corePath, 0, subProcessorThreadInterfaces, context,
        [aResp{aResp}, processorId, coreId, threadId,
         context](const boost::system::error_code& ec2,
                  const dbus::utility::MapperGetSubTreeResponse& subtree) {
        if (ec2)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error, ec2: " << ec2.value();
            // No sub processor core objects found by mapper
            if (ec2.value() == boost::system::errc::io_error)
            {
                messages::resourceNotFound(
                    aResp->res, "#Processor.v1_11_0.Processor", coreId);
                return;
            }

            messages::internalError(aResp->res);
            return;
        }

        std::vector<std::string> serviceNames =
            dbus_utils::getServiceNamesFromSubtree(subtree);

        sdbusplus::message::object_path path("/xyz/openbmc_project/inventory");
        dbus_utils::getManagedObjectsInEachService(
            std::move(serviceNames), path, context,
            [aResp{aResp}, subtree, processorId, coreId, threadId](
                const ManagedObjectByServiceMap& managedObjectsByService) {
            if (managedObjectsByService.empty())
            {
                messages::internalError(aResp->res);
                return;
            }

            for (const auto& [objectPath, serviceMap] : subtree)
            {
                if (sdbusplus::message::object_path(objectPath).filename() !=
                    threadId)
                {
                    continue;
                }

                getCoreThreadData(aResp, ""_json_pointer, 0, processorId,
                                  coreId, threadId, objectPath, subtree,
                                  managedObjectsByService);
                return;
            }

            // Object not found
            messages::resourceNotFound(
                aResp->res, "#Processor.v1_11_0.Processor", threadId);
        });
    });
}

inline void getSubProcessorThreadMembers(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& processorId, const std::string& coreId,
    const boost::system::error_code ec, const std::string& corePath)
{
    if (ec)
    {
        BMCWEB_LOG_DEBUG << "DBUS response error, ec: " << ec.value();
        // No sub processor core objects found by mapper
        if (ec.value() == boost::system::errc::io_error)
        {
            messages::resourceNotFound(aResp->res,
                                       "#Processor.v1_11_0.Processor", coreId);
            return;
        }

        messages::internalError(aResp->res);
        return;
    }

    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/ProcessorCollection/ProcessorCollection.json>; rel=describedby");
    aResp->res.jsonValue["@odata.type"] =
        "#ProcessorCollection.ProcessorCollection";
    aResp->res.jsonValue["@odata.id"] = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", "system", "Processors", processorId,
        "SubProcessors", coreId, "SubProcessors");
    aResp->res.jsonValue["Name"] = "SubProcessor Collection";

    const boost::urls::url& subProcessorsPath = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", "system", "Processors", processorId,
        "SubProcessors", coreId, "SubProcessors");

    constexpr std::array<std::string_view, 1> interfaces{
        "xyz.openbmc_project.Inventory.Item.CpuThread"};

    collection_util::getCollectionMembers(aResp, subProcessorsPath, interfaces,
                                          corePath.c_str());
}

inline void
    getCpuCoreData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                   const nlohmann::json::json_pointer& jsonPtr,
                   uint8_t expandLevel, const std::string& processorId,
                   const std::string& coreId, const std::string& corePath,
                   const dbus::utility::MapperGetSubTreeResponse& subtree,
                   const ManagedObjectByServiceMap& managedObjectsMap)
{
    aResp->res.jsonValue[jsonPtr]["@odata.type"] =
        "#Processor.v1_11_0.Processor";
    aResp->res.jsonValue[jsonPtr]["@odata.id"] = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", "system", "Processors", processorId,
        "SubProcessors", coreId);

    aResp->res.jsonValue[jsonPtr]["Name"] = "SubProcessor";
    aResp->res.jsonValue[jsonPtr]["ProcessorType"] = "Core";
    aResp->res.jsonValue[jsonPtr]["Id"] = coreId;

    if (expandLevel > 0)
    {
        nlohmann::json::json_pointer subProcessorPtr =
            jsonPtr / "SubProcessors";
        getSubProcessorThreadCollectionWithExpand(
            aResp, subProcessorPtr, expandLevel - 1, processorId, coreId,
            corePath, subtree, managedObjectsMap);
    }
    else
    {
        aResp->res.jsonValue[jsonPtr]["SubProcessors"]["@odata.id"] =
            crow::utility::urlFromPieces(
                "redfish", "v1", "Systems", "system", "Processors", processorId,
                "SubProcessors", coreId, "SubProcessors");
    }

    aResp->res.jsonValue[jsonPtr]["Status"]["State"] = "Enabled";
    aResp->res.jsonValue[jsonPtr]["Status"]["Health"] = "OK";

    bool present = false;
    bool functional = false;

    dbus::utility::MapperServiceMap serviceMap;
    for (const auto& [parsedObjectPath, parsedServiceMap] : subtree)
    {
        if (corePath == parsedObjectPath)
        {
            serviceMap = parsedServiceMap;
            break;
        }
    }

    for (const auto& [serviceName, interfaceList] : serviceMap)
    {
        auto iter = managedObjectsMap.find(serviceName);
        if (iter == managedObjectsMap.end())
        {
            BMCWEB_LOG_DEBUG << "Cpu data not available for serviceName "
                             << serviceName;
            continue;
        }

        for (const auto& interface : interfaceList)
        {
            dbus::utility::DBusPropertiesMap properties;
            if (interface == "xyz.openbmc_project.State."
                             "Decorator.OperationalStatus")
            {
                const bool* propertyFunctional = nullptr;
                dbus_utils::getPropertiesFromManagedObjects(
                    iter->second, corePath, interface, properties);
                const bool success = sdbusplus::unpackPropertiesNoThrow(
                    dbus_utils::UnpackErrorPrinter(), properties, "Functional",
                    propertyFunctional);

                if (!success)
                {
                    continue;
                }

                if (propertyFunctional != nullptr)
                {
                    functional = *propertyFunctional;
                }
            }
            else if (interface == "xyz.openbmc_project.Inventory.Item")
            {
                const bool* propertyPresent = nullptr;
                const std::string* propertyPrettyName = nullptr;
                dbus_utils::getPropertiesFromManagedObjects(
                    iter->second, corePath, interface, properties);
                const bool success = sdbusplus::unpackPropertiesNoThrow(
                    dbus_utils::UnpackErrorPrinter(), properties, "Present",
                    propertyPresent, "PrettyName", propertyPrettyName);

                if (!success)
                {
                    continue;
                }

                if (propertyPresent != nullptr)
                {
                    present = *propertyPresent;
                }

                if (propertyPrettyName != nullptr)
                {
                    aResp->res.jsonValue[jsonPtr]["Name"] = *propertyPrettyName;
                }
            }
            else if (interface == "xyz.openbmc_project.Inventory.Item.CpuCore")
            {
                const uint32_t* propertyMicrocode = nullptr;
                dbus_utils::getPropertiesFromManagedObjects(
                    iter->second, corePath, interface, properties);
                const bool success = sdbusplus::unpackPropertiesNoThrow(
                    dbus_utils::UnpackErrorPrinter(), properties, "Microcode",
                    propertyMicrocode);
                if (!success)
                {
                    continue;
                }

                if (propertyMicrocode != nullptr)
                {
                    aResp->res
                        .jsonValue[jsonPtr]["ProcessorId"]["MicrocodeInfo"] =
                        "0x" + intToHexString(*propertyMicrocode, 8);
                }
            }
        }
    }

    if (!present)
    {
        aResp->res.jsonValue[jsonPtr]["Status"]["State"] = "Absent";
    }

    if (!functional)
    {
        aResp->res.jsonValue[jsonPtr]["Status"]["Health"] = "Critical";
    }

    // The "Metrics" stanza is deliberately omitted at the Core layer
}

inline void getSubProcessorCoreData(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& processorId, const std::string& coreId,
    const boost::system::error_code ec, const std::string& cpuPath)
{
    if (ec)
    {
        BMCWEB_LOG_DEBUG << "DBUS response error, ec: " << ec.value();
        // No processor objects found by mapper
        if (ec.value() == boost::system::errc::io_error)
        {
            messages::resourceNotFound(
                aResp->res, "#Processor.v1_11_0.Processor", processorId);
            return;
        }

        messages::internalError(aResp->res);
        return;
    }
    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/Processor/Processor.json>; rel=describedby");

    std::array<std::string_view, 1> interfaces{
        "xyz.openbmc_project.Inventory.Item.CpuCore"};
    managedStore::ManagedObjectStoreContext context(aResp);
    managedStore::GetManagedObjectStore()->getSubTree(
        cpuPath, 0, interfaces, context,
        [aResp{aResp}, processorId, coreId,
         context](const boost::system::error_code& ec2,
                  const dbus::utility::MapperGetSubTreeResponse& subtree) {
        if (ec2)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error, ec2: " << ec2.value();
            // No processor objects found by mapper
            if (ec2.value() == boost::system::errc::io_error)
            {
                messages::resourceNotFound(
                    aResp->res, "#Processor.v1_11_0.Processor", processorId);
                return;
            }

            messages::internalError(aResp->res);
            return;
        }

        std::vector<std::string> serviceNames =
            dbus_utils::getServiceNamesFromSubtree(subtree);

        sdbusplus::message::object_path path("/xyz/openbmc_project/inventory");
        dbus_utils::getManagedObjectsInEachService(
            std::move(serviceNames), path, context,
            [aResp{aResp}, subtree, processorId,
             coreId](const ManagedObjectByServiceMap& managedObjectsByService) {
            if (managedObjectsByService.empty())
            {
                messages::internalError(aResp->res);
                return;
            }

            for (const auto& [objectPath, serviceMap] : subtree)
            {
                if (sdbusplus::message::object_path(objectPath).filename() !=
                    coreId)
                {
                    continue;
                }
                getCpuCoreData(aResp, ""_json_pointer, 0, processorId, coreId,
                               objectPath, subtree, managedObjectsByService);
                return;
            }

            // Object not found
            messages::resourceNotFound(aResp->res,
                                       "#Processor.v1_11_0.Processor", coreId);
        });
    });
}

inline void
    getSubProcessorCoreMembers(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                               const std::string& processorId,
                               const boost::system::error_code ec,
                               const std::string& cpuPath)
{
    if (ec)
    {
        BMCWEB_LOG_DEBUG << "DBUS response error, ec: " << ec.value();
        // No processor objects found by mapper
        if (ec.value() == boost::system::errc::io_error)
        {
            messages::resourceNotFound(
                aResp->res, "#Processor.v1_11_0.Processor", processorId);
            return;
        }

        messages::internalError(aResp->res);
        return;
    }

    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/ProcessorCollection/ProcessorCollection.json>; rel=describedby");
    aResp->res.jsonValue["@odata.type"] =
        "#ProcessorCollection.ProcessorCollection";
    aResp->res.jsonValue["@odata.id"] = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", "system", "Processors", processorId,
        "SubProcessors");
    aResp->res.jsonValue["Name"] = "SubProcessor Collection";

    const boost::urls::url& subProcessorsPath = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", "system", "Processors", processorId,
        "SubProcessors");

    constexpr std::array<std::string_view, 1> interfaces{
        "xyz.openbmc_project.Inventory.Item.CpuCore"};

    collection_util::getCollectionMembers(aResp, subProcessorsPath, interfaces,
                                          cpuPath.c_str());
}

inline void getSubProcessorThreadCollectionWithExpand(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const nlohmann::json::json_pointer& jsonPtr, uint8_t expandLevel,
    const std::string& processorId, const std::string& coreId,
    const std::string& corePath,
    const dbus::utility::MapperGetSubTreeResponse& subtree,
    const ManagedObjectByServiceMap& managedObjectsMap)
{
    aResp->res.jsonValue[jsonPtr]["Name"] = "SubProcessor Collection";
    aResp->res.jsonValue[jsonPtr]["@odata.type"] =
        "#ProcessorCollection.ProcessorCollection";
    aResp->res.jsonValue[jsonPtr]["@odata.id"] = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", "system", "Processors", processorId,
        "SubProcessors", coreId, "SubProcessors");

    // Maps thread ID to threadObjectPath
    std::map<std::string, std::string, AlphanumLess<std::string>>
        threadIdToObjectPath;

    for (const auto& [objectPath, serviceMap] : subtree)
    {
        if (!objectPath.starts_with(corePath) ||
            !dbus_utils::findInterfacesInServiceMap(
                serviceMap, subProcessorThreadInterfaces))
        {
            continue;
        }
        sdbusplus::message::object_path threadPath(objectPath);
        const std::string& threadId = threadPath.filename();
        threadIdToObjectPath.insert({threadId, threadPath});
    }

    BMCWEB_LOG_DEBUG << "Core path: " << corePath
                     << " thread count: " << threadIdToObjectPath.size();

    if (threadIdToObjectPath.empty())
    {
        BMCWEB_LOG_WARNING << "D-Bus CPU thread count was somehow empty";
        aResp->res.jsonValue[jsonPtr]["Members@odata.count"] = 0;
        aResp->res.jsonValue[jsonPtr]["Members"] = nlohmann::json::array();
        return;
    }

    size_t threadMemberCount = 0;
    for (const auto& [threadId, _] : threadIdToObjectPath)
    {
        nlohmann::json::json_pointer threadMemberPtr =
            jsonPtr / "Members" / threadMemberCount;
        if (expandLevel > 0)
        {
            getCoreThreadData(aResp, threadMemberPtr, expandLevel - 1,
                              processorId, coreId, threadId,
                              threadIdToObjectPath[threadId], subtree,
                              managedObjectsMap);
        }
        else
        {
            aResp->res.jsonValue[threadMemberPtr]["@odata.id"] =
                crow::utility::urlFromPieces("redfish", "v1", "Systems",
                                             "system", "Processors",
                                             processorId, "SubProcessors",
                                             coreId, "SubProcessors", threadId);
        }
        threadMemberCount++;
    }
    aResp->res.jsonValue[jsonPtr]["Members@odata.count"] = threadMemberCount;
}

inline void getSubProcessorCoreCollectionWithExpand(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const nlohmann::json::json_pointer& jsonPtr, uint8_t expandLevel,
    const std::string& processorId, const std::string& cpuPath,
    const dbus::utility::MapperGetSubTreeResponse& subtree,
    const ManagedObjectByServiceMap& managedObjectsMap)
{
    aResp->res.jsonValue[jsonPtr]["@odata.type"] =
        "#ProcessorCollection.ProcessorCollection";
    aResp->res.jsonValue[jsonPtr]["Name"] = "SubProcessor Collection";
    aResp->res.jsonValue[jsonPtr]["@odata.id"] = crow::utility::urlFromPieces(
        "redfish", "v1", "Systems", "system", "Processors", processorId,
        "SubProcessors");

    // Maps core ID to coreObjectPath
    std::map<std::string, std::string, AlphanumLess<std::string>>
        coreIdToObjectPath;

    for (const auto& [objectPath, serviceMap] : subtree)
    {
        if (!objectPath.starts_with(cpuPath) ||
            !dbus_utils::findInterfacesInServiceMap(serviceMap,
                                                    subProcessorCoreInterfaces))
        {
            continue;
        }
        sdbusplus::message::object_path corePath(objectPath);
        const std::string& coreId = corePath.filename();
        coreIdToObjectPath.insert({coreId, objectPath});
    }

    if (coreIdToObjectPath.empty())
    {
        BMCWEB_LOG_WARNING << "D-Bus CPU core count was somehow empty";
        aResp->res.jsonValue[jsonPtr]["Members@odata.count"] = 0;
        aResp->res.jsonValue[jsonPtr]["Members"] = nlohmann::json::array();
        return;
    }

    size_t coreMemberCount = 0;
    for (const auto& [coreId, _] : coreIdToObjectPath)
    {
        nlohmann::json::json_pointer coreMemberPtr =
            jsonPtr / "Members" / coreMemberCount;
        if (expandLevel > 0)
        {
            getCpuCoreData(aResp, coreMemberPtr, expandLevel - 1, processorId,
                           coreId, coreIdToObjectPath[coreId], subtree,
                           managedObjectsMap);
        }
        else
        {
            aResp->res.jsonValue[coreMemberPtr]["@odata.id"] =
                crow::utility::urlFromPieces(
                    "redfish", "v1", "Systems", "system", "Processors",
                    processorId, "SubProcessors", coreId);
        }
        coreMemberCount++;
    }

    aResp->res.jsonValue[jsonPtr]["Members@odata.count"] = coreMemberCount;
}

inline void getProcessorCollectionWithExpand(
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const dbus::utility::MapperGetSubTreeResponse& subtree,
    const ManagedObjectByServiceMap& managedObjectsMap, uint8_t expandLevel,
    const std::string& systemPath)
{
    BMCWEB_LOG_DEBUG << "Get processor collection with expand.";

    const bool multiHost = !systemPath.empty();

    // Maps cpu ID to cpuObjectPath.
    std::map<std::string, std::string, AlphanumLess<std::string>>
        cpuNameToObjectPath;

    for (const auto& [objectPath, serviceMap] : subtree)
    {

        if (!dbus_utils::findInterfacesInServiceMap(serviceMap,
                                                    processorInterfaces))
        {
            continue;
        }
        sdbusplus::message::object_path cpuPath(objectPath);

        // For multi-host systems, the object path of the cpu must be a
        // descendant of the systemPath. (e.g. if systemPath = /a/b, then
        // objectPath must be some pattern like /a/b/..)
        if (multiHost && !objectPath.starts_with(systemPath))
        {
            continue;
        }

        const std::string& cpuId = cpuPath.filename();
        cpuNameToObjectPath.insert({cpuId, cpuPath});
    }

    // If no cpus found, return
    if (cpuNameToObjectPath.empty())
    {
        BMCWEB_LOG_WARNING << "D-Bus CPU count was somehow empty";
        aResp->res.jsonValue["Members@odata.count"] = 0;
        aResp->res.jsonValue["Members"] = nlohmann::json::array();
        return;
    }

    size_t cpuMemberCount = 0;
    for (const auto& [cpu, _] : cpuNameToObjectPath)
    {
        nlohmann::json::json_pointer cpuMemberPtr =
            "/Members"_json_pointer / cpuMemberCount;
        getProcessorData(aResp, cpuMemberPtr, expandLevel - 1, cpu, systemPath,
                         cpuNameToObjectPath[cpu], subtree, managedObjectsMap);
        cpuMemberCount++;
    }

    aResp->res.jsonValue["Members@odata.count"] = cpuMemberCount;
    aResp->res.jsonValue["Name"] = "Processor Collection";
}

/**
 * Request all the properties for the given D-Bus object and fill out the
 * related entries in the Redfish OperatingConfig response.
 *
 * @param[in,out]   aResp       Async HTTP response.
 * @param[in]       service     D-Bus service name to query.
 * @param[in]       objPath     D-Bus object to query.
 */
inline void
    getOperatingConfigData(const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                           const std::string& service,
                           const std::string& objPath)
{
    managedStore::ManagedObjectStoreContext context(aResp);
    managedStore::GetManagedObjectStore()->getAllProperties(
        service, objPath,
        "xyz.openbmc_project.Inventory.Item.Cpu.OperatingConfig", context,
        [aResp](const boost::system::error_code& ec,
                const dbus::utility::DBusPropertiesMap& properties) {
        if (ec)
        {
            BMCWEB_LOG_WARNING << "D-Bus error: " << ec << ", " << ec.message();
            messages::internalError(aResp->res);
            return;
        }

        const size_t* availableCoreCount = nullptr;
        const uint32_t* baseSpeed = nullptr;
        const uint32_t* maxJunctionTemperature = nullptr;
        const uint32_t* maxSpeed = nullptr;
        const uint32_t* powerLimit = nullptr;
        const TurboProfileProperty* turboProfile = nullptr;
        const BaseSpeedPrioritySettingsProperty* baseSpeedPrioritySettings =
            nullptr;

        const bool success = sdbusplus::unpackPropertiesNoThrow(
            dbus_utils::UnpackErrorPrinter(), properties, "AvailableCoreCount",
            availableCoreCount, "BaseSpeed", baseSpeed,
            "MaxJunctionTemperature", maxJunctionTemperature, "MaxSpeed",
            maxSpeed, "PowerLimit", powerLimit, "TurboProfile", turboProfile,
            "BaseSpeedPrioritySettings", baseSpeedPrioritySettings);

        if (!success)
        {
            messages::internalError(aResp->res);
            return;
        }

        nlohmann::json& json = aResp->res.jsonValue;

        if (availableCoreCount != nullptr)
        {
            json["TotalAvailableCoreCount"] = *availableCoreCount;
        }

        if (baseSpeed != nullptr)
        {
            json["BaseSpeedMHz"] = *baseSpeed;
        }

        if (maxJunctionTemperature != nullptr)
        {
            json["MaxJunctionTemperatureCelsius"] = *maxJunctionTemperature;
        }

        if (maxSpeed != nullptr)
        {
            json["MaxSpeedMHz"] = *maxSpeed;
        }

        if (powerLimit != nullptr)
        {
            json["TDPWatts"] = *powerLimit;
        }

        if (turboProfile != nullptr)
        {
            nlohmann::json& turboArray = json["TurboProfile"];
            turboArray = nlohmann::json::array();
            for (const auto& [turboSpeed, coreCount] : *turboProfile)
            {
                nlohmann::json::object_t turbo;
                turbo["ActiveCoreCount"] = coreCount;
                turbo["MaxSpeedMHz"] = turboSpeed;
                turboArray.emplace_back(std::move(turbo));
            }
        }

        if (baseSpeedPrioritySettings != nullptr)
        {
            nlohmann::json& baseSpeedArray = json["BaseSpeedPrioritySettings"];
            baseSpeedArray = nlohmann::json::array();
            for (const auto& [baseSpeedMhz, coreList] :
                 *baseSpeedPrioritySettings)
            {
                nlohmann::json::object_t speed;
                speed["CoreCount"] = coreList.size();
                speed["CoreIDs"] = coreList;
                speed["BaseSpeedMHz"] = baseSpeedMhz;
                baseSpeedArray.emplace_back(std::move(speed));
            }
        }
    });
}

/**
 * Handle the D-Bus response from attempting to set the CPU's AppliedConfig
 * property. Main task is to translate error messages into Redfish errors.
 *
 * @param[in,out]   resp    HTTP response.
 * @param[in]       setPropVal  Value which we attempted to set.
 * @param[in]       ec      D-Bus response error code.
 * @param[in]       msg     D-Bus response message.
 */
inline void
    handleAppliedConfigResponse(const std::shared_ptr<bmcweb::AsyncResp>& resp,
                                const std::string& setPropVal,
                                const boost::system::error_code& ec,
                                const sdbusplus::message_t& msg)
{
    if (!ec)
    {
        BMCWEB_LOG_DEBUG << "Set Property succeeded";
        return;
    }

    BMCWEB_LOG_DEBUG << "Set Property failed: " << ec;

    const sd_bus_error* dbusError = msg.get_error();
    if (dbusError == nullptr)
    {
        messages::internalError(resp->res);
        return;
    }

    // The asio error code doesn't know about our custom errors, so we have to
    // parse the error string. Some of these D-Bus -> Redfish translations are a
    // stretch, but it's good to try to communicate something vaguely useful.
    if (strcmp(dbusError->name,
               "xyz.openbmc_project.Common.Error.InvalidArgument") == 0)
    {
        // Service did not like the object_path we tried to set.
        messages::propertyValueIncorrect(
            resp->res, "AppliedOperatingConfig/@odata.id", setPropVal);
    }
    else if (strcmp(dbusError->name,
                    "xyz.openbmc_project.Common.Error.NotAllowed") == 0)
    {
        // Service indicates we can never change the config for this processor.
        messages::propertyNotWritable(resp->res, "AppliedOperatingConfig");
    }
    else if (strcmp(dbusError->name,
                    "xyz.openbmc_project.Common.Error.Unavailable") == 0)
    {
        // Service indicates the config cannot be changed right now, but maybe
        // in a different system state.
        messages::resourceInStandby(resp->res);
    }
    else
    {
        messages::internalError(resp->res);
    }
}

/**
 * Handle the PATCH operation of the AppliedOperatingConfig property. Do basic
 * validation of the input data, and then set the D-Bus property.
 *
 * @param[in,out]   resp            Async HTTP response.
 * @param[in]       processorId     Processor's Id.
 * @param[in]       appliedConfigUri    New property value to apply.
 * @param[in]       cpuObjectPath   Path of CPU object to modify.
 * @param[in]       serviceMap      Service map for CPU object.
 */
inline void patchAppliedOperatingConfig(
    const std::shared_ptr<bmcweb::AsyncResp>& resp,
    const std::string& processorId, const std::string& appliedConfigUri,
    const std::string& cpuObjectPath,
    const dbus::utility::MapperGetSubTreeResponse& subtree,
    [[maybe_unused]] const ManagedObjectByServiceMap& managedObjectsMap)
{
    // Get Service map for the object path.
    dbus::utility::MapperServiceMap serviceMap;
    for (const auto& [parsedObjectPath, parsedServiceMap] : subtree)
    {
        if (cpuObjectPath == parsedObjectPath)
        {
            serviceMap = parsedServiceMap;
            break;
        }
    }

    // Check that the property even exists by checking for the interface
    const std::string* controlService = nullptr;
    for (const auto& [serviceName, interfaceList] : serviceMap)
    {
        if (std::find(interfaceList.begin(), interfaceList.end(),
                      "xyz.openbmc_project.Control.Processor."
                      "CurrentOperatingConfig") != interfaceList.end())
        {
            controlService = &serviceName;
            break;
        }
    }

    if (controlService == nullptr)
    {
        messages::internalError(resp->res);
        return;
    }

    // Check that the config URI is a child of the cpu URI being patched.
    std::string expectedPrefix("/redfish/v1/Systems/system/Processors/");
    expectedPrefix += processorId;
    expectedPrefix += "/OperatingConfigs/";
    if (!appliedConfigUri.starts_with(expectedPrefix) ||
        expectedPrefix.size() == appliedConfigUri.size())
    {
        messages::propertyValueIncorrect(
            resp->res, "AppliedOperatingConfig/@odata.id", appliedConfigUri);
        return;
    }

    // Generate the D-Bus path of the OperatingConfig object, by assuming it's a
    // direct child of the CPU object.
    // Strip the expectedPrefix from the config URI to get the "filename", and
    // append to the CPU's path.
    std::string configBaseName = appliedConfigUri.substr(expectedPrefix.size());
    sdbusplus::message::object_path configPath(cpuObjectPath);
    configPath /= configBaseName;

    BMCWEB_LOG_INFO << "Setting config to " << configPath.str;

    // Set the property, with handler to check error responses
    managedStore::GetManagedObjectStore()->PostDbusCallToIoContextThreadSafe(
        resp->strand_,
        [resp, appliedConfigUri](const boost::system::error_code& ec,
                                 const sdbusplus::message_t& msg) {
        handleAppliedConfigResponse(resp, appliedConfigUri, ec, msg);
    },
        *controlService, cpuObjectPath, "org.freedesktop.DBus.Properties",
        "Set", "xyz.openbmc_project.Control.Processor.CurrentOperatingConfig",
        "AppliedConfig", dbus::utility::DbusVariantType(std::move(configPath)));
}

inline void handleSubProcessorThreadHead(
    crow::App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& /* systemName */, const std::string& /* processorId */,
    const std::string& /* coreId */, const std::string& /* threadId */)
{
    if (!redfish::setUpRedfishRoute(app, req, aResp))
    {
        return;
    }
    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/Processor/Processor.json>; rel=describedby");
}

inline void handleSubProcessorThreadCollectionHead(
    crow::App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& /* systemName */, const std::string& /* processorId */,
    const std::string& /* coreId */)
{
    if (!redfish::setUpRedfishRoute(app, req, aResp))
    {
        return;
    }
    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/ProcessorCollection/ProcessorCollection.json>; rel=describedby");
}

inline void
    handleSubProcessorCoreHead(crow::App& app, const crow::Request& req,
                               const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                               const std::string& /* systemName */,
                               const std::string& /* processorId */,
                               const std::string& /* coreId */)
{
    if (!redfish::setUpRedfishRoute(app, req, aResp))
    {
        return;
    }
    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/Processor/Processor.json>; rel=describedby");
}

inline void handleSubProcessorCoreCollectionHead(
    crow::App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& /* systemName */, const std::string& /* processorId */)
{
    if (!redfish::setUpRedfishRoute(app, req, aResp))
    {
        return;
    }
    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/ProcessorCollection/ProcessorCollection.json>; rel=describedby");
}

inline void handleProcessorHead(crow::App& app, const crow::Request& req,
                                const std::shared_ptr<bmcweb::AsyncResp>& aResp,
                                const std::string& /* systemName */,
                                const std::string& /* processorId */)
{
    if (!redfish::setUpRedfishRoute(app, req, aResp))
    {
        return;
    }
    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/Processor/Processor.json>; rel=describedby");
}

inline void handleProcessorCollectionHead(
    crow::App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& aResp,
    const std::string& /* systemName */)
{
    if (!redfish::setUpRedfishRoute(app, req, aResp))
    {
        return;
    }
    aResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/ProcessorCollection/ProcessorCollection.json>; rel=describedby");
}

inline void parseSubtreeForProcessorCollection(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const dbus::utility::MapperGetSubTreeResponse& subtree,
    const query_param::Query& delegated, const std::string& systemPath)
{
    const bool multiHost = !systemPath.empty();

    // Default systemName is system and change if system is multi-host
    std::string systemName = "system";

    if (multiHost)
    {
        systemName = sdbusplus::message::object_path(systemPath).filename();
    }

    if (delegated.expandLevel == 0 ||
        delegated.expandType == query_param::ExpandType::None)
    {
        BMCWEB_LOG_DEBUG << "Use default processor expand handler";
        collection_util::getCollectionMembersFromSubtree(
            asyncResp,
            boost::urls::url("/redfish/v1/Systems/" + systemName +
                             "/Processors"),
            processorInterfaces, subtree);
        return;
    }
    BMCWEB_LOG_DEBUG << "Use efficient processor expand handler";

    std::vector<std::string> serviceNames =
        dbus_utils::getServiceNamesFromSubtree(subtree);
    if (serviceNames.empty())
    {
        BMCWEB_LOG_DEBUG << "Can't retrieve service names from subtree";
        asyncResp->res.jsonValue["Members@odata.count"] = 0;
        asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
        return;
    }

    managedStore::ManagedObjectStoreContext context(asyncResp);
    // Get managed objects from each service in subtree to proactively
    // fetch all dbus data needed to serve requests for subordinate
    // resources.
    sdbusplus::message::object_path path("/xyz/openbmc_project/inventory");
    dbus_utils::getManagedObjectsInEachService(
        std::move(serviceNames), path, context,
        [asyncResp{asyncResp}, subtree, delegated,
         systemPath](const ManagedObjectByServiceMap& managedObjectsByService) {
        if (managedObjectsByService.empty())
        {
            BMCWEB_LOG_DEBUG << "Cannot get managed objects.";
            messages::internalError(asyncResp->res);
            return;
        }
        getProcessorCollectionWithExpand(asyncResp, subtree,
                                         managedObjectsByService,
                                         delegated.expandLevel, systemPath);
    });
}

inline void handleProcessorCollection(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const query_param::Query& delegated, const std::string& systemPath)
{
    const bool multiHost = !systemPath.empty();

    // Default systemName is system and change if system is multi-host
    std::string systemName = "system";
    // The subtree to query for Dimms changes if single or multi-host
    std::string subtreeRoot = "/xyz/openbmc_project/inventory";

    if (multiHost)
    {
        systemName = sdbusplus::message::object_path(systemPath).filename();
        subtreeRoot = systemPath;
    }

    asyncResp->res.addHeader(
        boost::beast::http::field::link,
        "</redfish/v1/JsonSchemas/ProcessorCollection/ProcessorCollection.json>; rel=describedby");

    asyncResp->res.jsonValue["@odata.type"] =
        "#ProcessorCollection.ProcessorCollection";
    asyncResp->res.jsonValue["Name"] = "Processor Collection";

    asyncResp->res.jsonValue["@odata.id"] =
        "/redfish/v1/Systems/" + systemName + "/Processors";

    // Get dbus interfaces based on expand level.
    auto interfaces = getInterfacesForProcessorSubtree(delegated.expandLevel);

    if (interfaces.empty())
    {
        BMCWEB_LOG_ERROR << "Can't get interface list for expand level "
                         << delegated.expandLevel;
        messages::internalError(asyncResp->res);
        return;
    }

    // Get subtree information to serve requests for both processor
    // collection and, if expand is requested, for all requested subordinate
    // resources.
    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    managedStore::GetManagedObjectStore()->getSubTree(
        subtreeRoot, 0, interfaces, requestContext,
        [asyncResp{asyncResp}, delegated,
         systemPath](const boost::system::error_code& ec,
                     const dbus::utility::MapperGetSubTreeResponse& subtree) {
        if (ec == boost::system::errc::io_error)
        {
            asyncResp->res.jsonValue["Members"] = nlohmann::json::array();
            asyncResp->res.jsonValue["Members@odata.count"] = 0;
            return;
        }

        if (ec)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error " << ec.value();
            messages::internalError(asyncResp->res);
            return;
        }
        parseSubtreeForProcessorCollection(asyncResp, subtree, delegated,
                                           systemPath);
    });
}

inline void handleOperatingConfigCollectionGet(
    App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& cpuName)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }
    asyncResp->res.jsonValue["@odata.type"] =
        "#OperatingConfigCollection.OperatingConfigCollection";
    asyncResp->res.jsonValue["@odata.id"] =
        crow::utility::urlFromPieces("redfish", "v1", "Systems", "system",
                                     "Processors", cpuName, "OperatingConfigs");
    asyncResp->res.jsonValue["Name"] = "Operating Config Collection";

    // First find the matching CPU object so we know how to
    // constrain our search for related Config objects.
    const std::array<std::string_view, 1> interfaces = {
        "xyz.openbmc_project.Control.Processor.CurrentOperatingConfig"};
    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    managedStore::GetManagedObjectStore()->getSubTreePaths(
        "/xyz/openbmc_project/inventory", 0, interfaces, requestContext,
        [asyncResp,
         cpuName](const boost::system::error_code& ec,
                  const dbus::utility::MapperGetSubTreePathsResponse& objects) {
        if (ec)
        {
            BMCWEB_LOG_WARNING << "D-Bus error: " << ec << ", " << ec.message();
            messages::internalError(asyncResp->res);
            return;
        }

        for (const std::string& object : objects)
        {
            if (!object.ends_with(cpuName))
            {
                continue;
            }

            // Not expected that there will be multiple matching
            // CPU objects, but if there are just use the first
            // one.

            // Use the common search routine to construct the
            // Collection of all Config objects under this CPU.
            constexpr std::array<std::string_view, 1> interface{
                "xyz.openbmc_project.Inventory.Item.Cpu.OperatingConfig"};
            collection_util::getCollectionMembers(
                asyncResp,
                crow::utility::urlFromPieces("redfish", "v1", "Systems",
                                             "system", "Processors", cpuName,
                                             "OperatingConfigs"),
                interface, object.c_str());
            return;
        }
    });
}

inline void requestRoutesOperatingConfigCollection(App& app)
{
    BMCWEB_ROUTE(
        app, "/redfish/v1/Systems/system/Processors/<str>/OperatingConfigs/")
        .privileges(redfish::privileges::getOperatingConfigCollection)
        .methods(boost::beast::http::verb::get)(
            std::bind_front(handleOperatingConfigCollectionGet, std::ref(app)));
}

inline void handleOperatingConfigGet(
    App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& cpuName, const std::string& configName)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }
    // Ask for all objects implementing OperatingConfig so we can search
    // for one with a matching name
    constexpr std::array<std::string_view, 1> interfaces = {
        "xyz.openbmc_project.Inventory.Item.Cpu.OperatingConfig"};
    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    managedStore::GetManagedObjectStore()->getSubTree(
        "/xyz/openbmc_project/inventory", 0, interfaces, requestContext,
        [asyncResp, cpuName,
         configName](const boost::system::error_code& ec,
                     const dbus::utility::MapperGetSubTreeResponse& subtree) {
        if (ec)
        {
            BMCWEB_LOG_WARNING << "D-Bus error: " << ec << ", " << ec.message();
            messages::internalError(asyncResp->res);
            return;
        }
        const std::string expectedEnding = cpuName + '/' + configName;
        for (const auto& [objectPath, serviceMap] : subtree)
        {
            // Ignore any configs without matching cpuX/configY
            if (!objectPath.ends_with(expectedEnding) || serviceMap.empty())
            {
                continue;
            }

            nlohmann::json& json = asyncResp->res.jsonValue;
            json["@odata.type"] = "#OperatingConfig.v1_0_0.OperatingConfig";
            json["@odata.id"] = crow::utility::urlFromPieces(
                "redfish", "v1", "Systems", "system", "Processors", cpuName,
                "OperatingConfigs", configName);
            json["Name"] = "Processor Profile";
            json["Id"] = configName;

            // Just use the first implementation of the object - not
            // expected that there would be multiple matching
            // services
            getOperatingConfigData(asyncResp, serviceMap.begin()->first,
                                   objectPath);
            return;
        }
        messages::resourceNotFound(asyncResp->res, "OperatingConfig",
                                   configName);
    });
}

inline void requestRoutesOperatingConfig(App& app)
{
    BMCWEB_ROUTE(
        app,
        "/redfish/v1/Systems/system/Processors/<str>/OperatingConfigs/<str>/")
        .privileges(redfish::privileges::getOperatingConfig)
        .methods(boost::beast::http::verb::get)(
            std::bind_front(handleOperatingConfigGet, std::ref(app)));
}

inline int countProcessors()
{
    // TODO(): This is a STUB
    // For now, this is OK, since it is only used for syntax validation.
    // However, when and if writing (POST, PATCH, etc.) is allowed,
    // we will need to have better bounds-checking here,
    // otherwise it will be trivial for a writer to DoS all the storage.
    return 16;
}

inline int countCores(int cpuIndex)
{
    // TODO(): This is a STUB, see above comment
    (void)cpuIndex;
    return 256;
}

inline int countThreads(int cpuIndex, int coreIndex)
{
    // TODO(): This is a STUB, see above comment
    (void)cpuIndex;
    (void)coreIndex;
    return 16;
}

inline int prefixStrToInt(const std::string& prefix, const std::string& str)
{
    size_t lenPrefix = prefix.size();
    size_t lenStr = str.size();

    // Content following prefix must be within 1 to 9 characters in length
    if (lenStr < (lenPrefix + 1))
    {
        BMCWEB_LOG_ERROR << "Index number too short";
        return -1;
    }
    if (lenStr > (lenPrefix + 9))
    {
        // This length limit prevents 32-bit rollover attacks
        BMCWEB_LOG_ERROR << "Index number too long";
        return -1;
    }

    if (str.substr(0, lenPrefix) != prefix)
    {
        // Prefix does not match
        BMCWEB_LOG_ERROR << "Index number wrong prefix";
        return -1;
    }

    std::string numText = str.substr(lenPrefix);
    size_t lenText = numText.size();
    size_t lenCheck = std::strlen(numText.c_str());
    if (lenText != lenCheck)
    {
        // This comparison prevents 0x00 string truncation attacks
        BMCWEB_LOG_ERROR << "Index number wrong length";
        return -1;
    }

    // Cannot use std::stoi because stoi throws
    char* endptr = nullptr;
    int64_t value = std::strtol(numText.c_str(), &endptr, 10);
    if (*endptr != '\0')
    {
        // The number was followed by extra content
        BMCWEB_LOG_ERROR << "Index number wrong content";
        return -1;
    }

    int result = static_cast<int>(value);
    return result;
}

inline int extractIndexFromArg(const std::string& arg)
{
    const std::string index =
        arg.substr(arg.find_last_not_of("0123456789") + 1);
    if (index.empty())
    {
        BMCWEB_LOG_ERROR << "Unable to extract index from arg";
        return -1;
    }
    // use std::strtol since std::stoi can throw
    char* enptr = nullptr;
    int64_t value = std::strtol(index.c_str(), &enptr, 10);
    return static_cast<int>(value);
}

inline int cpuArgToIndex(const std::string& cpuArg)
{
    int bound = countProcessors();
    int num = extractIndexFromArg(cpuArg);
    if (num >= bound)
    {
        BMCWEB_LOG_ERROR << "Processor index out of range";
        return -1;
    }
    return num;
}

inline int coreArgToIndex(const std::string& coreArg, int cpuIndex)
{

    int bound = countCores(cpuIndex);
    int num = prefixStrToInt("core", coreArg);
    if (num >= bound)
    {
        BMCWEB_LOG_ERROR << "Subprocessor core index out of range";
        return -1;
    }
    return num;
}

inline int threadArgToIndex(const std::string& threadArg, int cpuIndex,
                            int coreIndex)
{

    int bound = countThreads(cpuIndex, coreIndex);
    int num = prefixStrToInt("thread", threadArg);
    if (num >= bound)
    {
        BMCWEB_LOG_ERROR << "Subprocessor thread index out of range";
        return -1;
    }
    return num;
}

inline int validateCpu(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                       const std::string& cpuArg)
{
    int cpuIndex = cpuArgToIndex(cpuArg);
    if (cpuIndex < 0)
    {
        messages::resourceNotFound(asyncResp->res, "Processor", cpuArg);
    }
    return cpuIndex;
}

inline int validateCpuCore(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                           const std::string& cpuArg,
                           const std::string& coreArg)
{
    int cpuIndex = validateCpu(asyncResp, cpuArg);
    if (cpuIndex < 0)
    {
        return cpuIndex;
    }
    int coreIndex = coreArgToIndex(coreArg, cpuIndex);
    if (coreIndex < 0)
    {
        messages::resourceNotFound(asyncResp->res, "Core", coreArg);
    }
    return coreIndex;
}

inline int
    validateCpuCoreThread(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                          const std::string& cpuArg, const std::string& coreArg,
                          const std::string& threadArg)
{
    int cpuIndex = validateCpu(asyncResp, cpuArg);
    if (cpuIndex < 0)
    {
        return cpuIndex;
    }
    int coreIndex = validateCpuCore(asyncResp, cpuArg, coreArg);
    if (coreIndex < 0)
    {
        return coreIndex;
    }
    int threadIndex = threadArgToIndex(threadArg, cpuIndex, coreIndex);
    if (threadIndex < 0)
    {
        messages::resourceNotFound(asyncResp->res, "Thread", threadArg);
    }
    return threadIndex;
}

// Creates a generic ExternalStorer hook, should be 2 directories above
// Each hook contains instances, each instance contains entries
// Omit the leading "/redfish/v1" from pathBase, and no trailing slash
inline external_storer::Hook makeExternalStorerHook(const std::string& pathBase)
{
    const std::string emptyString;
    const std::vector<std::string> emptyList;

    return {pathBase, emptyString, emptyList, emptyList};
}

// Creates a generic ExternalStorer instance within the given hook
// The content will be minimal, just enough to create filename on disk
// Returns true if successful
inline bool makeExternalStorerInstance(
    const std::shared_ptr<external_storer::Hook>& hook, const std::string& id)
{
    // External storer NEVER sends dbus calls, so you will never leave this thread.
    auto respGet = std::make_shared<bmcweb::AsyncResp>(nullptr);

    hook->handleGetInstance(respGet, id);
    if (respGet->res.result() == boost::beast::http::status::ok)
    {
        // Already exists, nothing more needs to be done
        return true;
    }

    boost::beast::http::request<boost::beast::http::string_body> upBody;
    std::error_code ec;

    // Create instance, with given ID, which will become filename on disk
    auto upJson = nlohmann::json::object();
    upJson["Id"] = id;

    // Must supply 4th argument to avoid throwing exceptions
    upBody.body() =
        upJson.dump(-1, ' ', false, nlohmann::json::error_handler_t::replace);
    crow::Request reqCreate{upBody, ec};

    // External storer NEVER sends dbus calls, so you will never leave this thread.
    auto respCreate = std::make_shared<bmcweb::AsyncResp>(nullptr);

    hook->handleCreateInstance(reqCreate, respCreate);
    if (respCreate->res.result() != boost::beast::http::status::created)
    {
        BMCWEB_LOG_ERROR << "Problem creating ExternalStorer instance " << id;
        return false;
    }

    return true;
}

// Remembers toplevel Processors hook, there is only one
// Each instance in it represents a CPU and is named like cpuArg
// Each instance contains only one entry, "ProcessorMetrics"
inline std::shared_ptr<external_storer::Hook>
    rememberProcessorHook(const std::string& cpuArg)
{
    static std::shared_ptr<external_storer::Hook> hookProcessor = nullptr;

    if (!hookProcessor)
    {
        // If not already remembered by static variable, create hook
        hookProcessor = std::make_shared<external_storer::Hook>(
            makeExternalStorerHook("Systems/system/Processors"));
    }

    if (!(makeExternalStorerInstance(hookProcessor, cpuArg)))
    {
        BMCWEB_LOG_ERROR << "Problem remembering hook for " << cpuArg;
        return nullptr;
    }

    return hookProcessor;
}

// Remembers lowest-level SubProcessors hook
// There is one hook for each unique (CPU, thread) tuple
// Each instance in it represents a thread and is named like threadArg
// Each instance contains only one entry, "ProcessorMetrics"
inline std::shared_ptr<external_storer::Hook>
    rememberThreadHook(const std::string& cpuArg, const std::string& coreArg,
                       const std::string& threadArg)
{
    static std::map<
        std::string,
        std::map<std::string, std::shared_ptr<external_storer::Hook>>>
        hookMaps;

    auto findCpu = hookMaps.find(cpuArg);
    if (findCpu == hookMaps.end())
    {
        hookMaps[cpuArg] = {};
        findCpu = hookMaps.find(cpuArg);
    }

    auto findCore = findCpu->second.find(coreArg);
    if (findCore == findCpu->second.end())
    {
        (findCpu->second)[coreArg] = {};
        findCore = findCpu->second.find(coreArg);
    }

    std::shared_ptr<external_storer::Hook> hookThread = findCore->second;

    if (!hookThread)
    {
        std::string path = "Systems/system/Processors/" + cpuArg +
                           "/SubProcessors/" + coreArg + "/SubProcessors";
        hookThread = std::make_shared<external_storer::Hook>(
            makeExternalStorerHook(path));
        findCore->second = hookThread;
    }

    if (!(makeExternalStorerInstance(hookThread, threadArg)))
    {
        BMCWEB_LOG_ERROR << "Problem remembering hook for " << threadArg;
        return nullptr;
    }

    return hookThread;
}

inline nlohmann::json fakeProcessorMetrics(const std::string& cpu,
                                           const std::string& core,
                                           const std::string& thread)
{
    nlohmann::json::object_t metricsObj;

    metricsObj["Id"] = "Metrics";
    metricsObj["Name"] = "Processor Metrics";

    // The different levels have slightly different default content
    if (!thread.empty())
    {
        // Thread level
        metricsObj["CorrectableCoreErrorCount"] = 0;
        metricsObj["UncorrectableCoreErrorCount"] = 0;
    }
    metricsObj["CorrectableOtherErrorCount"] = 0;
    metricsObj["UncorrectableOtherErrorCount"] = 0;

    // ExternalStorer would normally apply this as invariant if successful
    // The caller already applies "@odata.type" as invariant no matter what
    std::string url = "/redfish/v1/Systems/system/Processors/";
    url += cpu;
    if (!core.empty())
    {
        url += "/SubProcessors/";
        url += core;
    }
    if (!thread.empty())
    {
        url += "/SubProcessors/";
        url += thread;
    }
    url += "/ProcessorMetrics";

    metricsObj["@odata.id"] = std::move(url);

    return metricsObj;
}

inline void
    handleGetCpuMetrics(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                        const nlohmann::json::json_pointer& jsonPtr,
                        const std::string& cpuArg)
{
    if (validateCpu(asyncResp, cpuArg) < 0)
    {
        // Error reply already composed
        return;
    }

    std::shared_ptr<external_storer::Hook> hook = rememberProcessorHook(cpuArg);
    if (!hook)
    {
        messages::resourceNotFound(asyncResp->res, "Processor", cpuArg);
        return;
    }

    std::string emptyString;
    hook->handleGetEntry(asyncResp, jsonPtr, cpuArg, emptyString,
                         "ProcessorMetrics");
    if (asyncResp->res.result() == boost::beast::http::status::not_found)
    {
        // Fake up a synthetic response to replace only the 404 error
        asyncResp->res.jsonValue[jsonPtr] =
            fakeProcessorMetrics(cpuArg, "", "");
        asyncResp->res.result(boost::beast::http::status::ok);
    }
    if (asyncResp->res.result() != boost::beast::http::status::ok)
    {
        // Error reply already composed
        return;
    }

    // Apply invariants, to override whatever might have been in the file
    asyncResp->res.jsonValue[jsonPtr]["@odata.type"] =
        "#ProcessorMetrics.v1_5_0.ProcessorMetrics";
}

inline void handleGetCpuCoreThreadMetrics(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const nlohmann::json::json_pointer& jsonPtr, const std::string& cpuArg,
    const std::string& coreArg, const std::string& threadArg)
{
    if (validateCpuCoreThread(asyncResp, cpuArg, coreArg, threadArg) < 0)
    {
        return;
    }

    std::shared_ptr<external_storer::Hook> hook =
        rememberThreadHook(cpuArg, coreArg, threadArg);
    if (!hook)
    {
        messages::resourceNotFound(asyncResp->res, "Thread", threadArg);
        return;
    }

    std::string emptyString;
    hook->handleGetEntry(asyncResp, jsonPtr, threadArg, emptyString,
                         "ProcessorMetrics");
    if (asyncResp->res.result() == boost::beast::http::status::not_found)
    {
        // Fake up a synthetic response to replace only the 404 error
        asyncResp->res.jsonValue[jsonPtr] =
            fakeProcessorMetrics(cpuArg, coreArg, threadArg);
        asyncResp->res.result(boost::beast::http::status::ok);
    }
    if (asyncResp->res.result() != boost::beast::http::status::ok)
    {
        // Error reply already composed
        return;
    }

    // Apply invariants, to override whatever might have been in the file
    asyncResp->res.jsonValue[jsonPtr]["@odata.type"] =
        "#ProcessorMetrics.v1_5_0.ProcessorMetrics";
}

// The glue layers are already handled by these functions elsewhere:
// Processors = requestRoutesProcessorCollection()
// Processors/cpuX = requestRoutesProcessor()
// Processors/cpuX/SubProcessors = requestRoutesSubProcessorCoreCollection()
// Processors/cpuX/SubProcessors/coreY = requestRoutesSubProcessorCore()
// Processors/cpuX/SubProcessors/coreY/SubProcessors =
// requestRoutesSubProcessorThreadCollection()
// Processors/cpuX/SubProcessors/coreY/SubProcessors/threadZ =
// requestRoutesSubProcessorThread()

// The "ProcessorMetrics" endpoints are below those glue layers:
// Processors/cpuX/ProcessorMetrics = handled here
// Processors/cpuX/SubProcessors/coreY/ProcessorMetrics = intentionally
// omitted
// Processors/cpuX/SubProcessors/coreY/SubProcessors/threadZ/ProcessorMetrics
// = handled here
inline void requestRoutesProcessorMetricsViaExternalStorer(App& app)
{
    BMCWEB_ROUTE(
        app, "/redfish/v1/Systems/system/Processors/<str>/ProcessorMetrics/")
        .privileges(redfish::privileges::getProcessor)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& cpuArg) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp))
        {
            return;
        }
        handleGetCpuMetrics(asyncResp, ""_json_pointer, cpuArg);
    });

    BMCWEB_ROUTE(
        app,
        "/redfish/v1/Systems/system/Processors/<str>/SubProcessors/<str>/SubProcessors/<str>/ProcessorMetrics/")
        .privileges(redfish::privileges::getProcessor)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& cpuArg, const std::string& coreArg,
                   const std::string& threadArg) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp))
        {
            return;
        }
        handleGetCpuCoreThreadMetrics(asyncResp, ""_json_pointer, cpuArg,
                                      coreArg, threadArg);
    });

    // TODO(): Implement corresponding PATCH methods
    // The POST method is not correct to use here,
    // as the result location is already well-known name "ProcessorMetrics".
    // and from the user point of view it always exists,
    // so the creation operation is not the correct operation.
    // The PUT method also might not be correct to use here,
    // as it would fully replace all content at the result location,
    // but the expectation is to only selectively replace some content.
}

inline void requestRoutesProcessorCollection(App& app)
{
    /**
     * Functions triggers appropriate requests on DBus
     */
    BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/")
        .privileges(redfish::privileges::headProcessorCollection)
        .methods(boost::beast::http::verb::head)(
            std::bind_front(handleProcessorCollectionHead, std::ref(app)));

    BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/")
        .privileges(redfish::privileges::getProcessorCollection)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& systemName) {
        query_param::Query delegated;
        query_param::QueryCapabilities capabilities = {
#ifdef EFFICIENT_EXPAND_PROCESSORS_ENABLED
            .canDelegateExpandLevel = 6,
#else
            .canDelegateExpandLevel = 0,
#endif
        };
        if (!redfish::setUpRedfishRouteWithDelegation(app, req, asyncResp,
                                                      delegated, capabilities))
        {
            return;
        }

        redfish::system_utils::getSystemInformation(
            asyncResp, systemName,
            [delegated](const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                        const std::string& systemPath) {
            handleProcessorCollection(asyncResp, delegated, systemPath);
        });
    });
}

inline void getProcessorStateCollection(
    App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& systemName, const std::string& processorId)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }
    constexpr std::array<std::string_view, 1> procStateIntf = {
        "xyz.openbmc_project.Inventory.Item.ProcessorState"};
    collection_util::getCollectionMembers(
        asyncResp,
        crow::utility::urlFromPieces("redfish", "v1", "Systems", systemName,
                                     "Processors", processorId, "Oem", "Google",
                                     "ProcessorStates"),
        procStateIntf);
}

inline void
    handleProcessorGet(App& app, const crow::Request& req,
                       const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                       const std::string& systemName,
                       const std::string& processorId)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }

    redfish::system_utils::getSystemInformation(
        asyncResp, systemName,
        [processorId](const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                      const std::string& systemPath) {
        getProcessorObject(asyncResp, processorId, systemPath,
                           std::bind_front(getProcessorData, asyncResp,
                                           ""_json_pointer, 0, processorId,
                                           systemPath));
    });
}

inline void
    handleProcessorPatch(App& app, const crow::Request& req,
                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                         const std::string& systemName,
                         const std::string& processorId)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }
    if (systemName != "system")
    {
        messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                   systemName);
        return;
    }

    std::optional<nlohmann::json> appliedConfigJson;
    if (!json_util::readJsonPatch(req, asyncResp->res, "AppliedOperatingConfig",
                                  appliedConfigJson))
    {
        return;
    }

    if (appliedConfigJson)
    {
        std::string appliedConfigUri;
        if (!json_util::readJson(*appliedConfigJson, asyncResp->res,
                                 "@odata.id", appliedConfigUri))
        {
            return;
        }

        redfish::system_utils::getSystemInformation(
            asyncResp, systemName,
            [processorId, appliedConfigUri](
                const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                const std::string& systemPath) {
            // Check for 404 and find matching D-Bus object, then run
            // property patch handlers if that all succeeds.
            getProcessorObject(asyncResp, processorId, systemPath,
                               std::bind_front(patchAppliedOperatingConfig,
                                               asyncResp, processorId,
                                               appliedConfigUri));
        });
    }
}

inline void requestRoutesProcessor(App& app)
{
    /**
     * Functions triggers appropriate requests on DBus
     */

    BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/<str>/")
        .privileges(redfish::privileges::headProcessor)
        .methods(boost::beast::http::verb::head)(
            std::bind_front(handleProcessorHead, std::ref(app)));

    BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/<str>/")
        .privileges(redfish::privileges::getProcessor)
        .methods(boost::beast::http::verb::get)(
            std::bind_front(handleProcessorGet, std::ref(app)));

    BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Processors/<str>/")
        .privileges(redfish::privileges::patchProcessor)
        .methods(boost::beast::http::verb::patch)(
            std::bind_front(handleProcessorPatch, std::ref(app)));

    BMCWEB_ROUTE(
        app,
        "/redfish/v1/Systems/<str>/Processors/<str>/Oem/Google/ProcessorStates/")
        .privileges(redfish::privileges::getProcessor)
        .methods(boost::beast::http::verb::get)(
            std::bind_front(getProcessorStateCollection, std::ref(app)));

    BMCWEB_ROUTE(
        app,
        "/redfish/v1/Systems/<str>/Processors/<str>/Oem/Google/ProcessorStates/<str>/")
        .privileges(redfish::privileges::getProcessor)
        .methods(boost::beast::http::verb::get)(
            std::bind_front(handleGetProcessorState, std::ref(app)));
}

inline void requestRoutesSubProcessorCoreCollection(App& app)
{
    BMCWEB_ROUTE(app,
                 "/redfish/v1/Systems/<str>/Processors/<str>/SubProcessors/")
        .privileges(redfish::privileges::headProcessorCollection)
        .methods(boost::beast::http::verb::head)(std::bind_front(
            handleSubProcessorCoreCollectionHead, std::ref(app)));

    BMCWEB_ROUTE(app,
                 "/redfish/v1/Systems/<str>/Processors/<str>/SubProcessors/")
        .privileges(redfish::privileges::getProcessorCollection)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& systemName,
                   const std::string& processorId) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp))
        {
            return;
        }
        if (systemName != "system")
        {
            messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                       systemName);
            return;
        }

        BMCWEB_LOG_DEBUG << "Get available system sub processor core members.";

        getProcessorPaths(asyncResp, processorId,
                          std::bind_front(getSubProcessorCoreMembers, asyncResp,
                                          processorId));
    });
}

inline void requestRoutesSubProcessorCore(App& app)
{
    BMCWEB_ROUTE(
        app, "/redfish/v1/Systems/<str>/Processors/<str>/SubProcessors/<str>/")
        .privileges(redfish::privileges::headProcessor)
        .methods(boost::beast::http::verb::head)(
            std::bind_front(handleSubProcessorCoreHead, std::ref(app)));

    BMCWEB_ROUTE(
        app, "/redfish/v1/Systems/<str>/Processors/<str>/SubProcessors/<str>/")
        .privileges(redfish::privileges::getProcessor)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& systemName,
                   const std::string& processorId, const std::string& coreId) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp))
        {
            return;
        }
        if (systemName != "system")
        {
            messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                       systemName);
            return;
        }

        BMCWEB_LOG_DEBUG
            << "Get available system sub processor core resources.";

        getProcessorPaths(asyncResp, processorId,
                          std::bind_front(getSubProcessorCoreData, asyncResp,
                                          processorId, coreId));
    });
}

inline void requestRoutesSubProcessorThreadCollection(App& app)
{
    BMCWEB_ROUTE(
        app,
        "/redfish/v1/Systems/<str>/Processors/<str>/SubProcessors/<str>/SubProcessors/")
        .privileges(redfish::privileges::headProcessorCollection)
        .methods(boost::beast::http::verb::head)(std::bind_front(
            handleSubProcessorThreadCollectionHead, std::ref(app)));
    BMCWEB_ROUTE(
        app,
        "/redfish/v1/Systems/<str>/Processors/<str>/SubProcessors/<str>/SubProcessors/")
        .privileges(redfish::privileges::getProcessorCollection)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& systemName,
                   const std::string& processorId, const std::string& coreId) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp))
        {
            return;
        }
        if (systemName != "system")
        {
            messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                       systemName);
            return;
        }

        getSubProcessorCorePaths(asyncResp, processorId, coreId,
                                 std::bind_front(getSubProcessorThreadMembers,
                                                 asyncResp, processorId,
                                                 coreId));
    });
}

inline void requestRoutesSubProcessorThread(App& app)
{
    BMCWEB_ROUTE(
        app,
        "/redfish/v1/Systems/<str>/Processors/<str>/SubProcessors/<str>/SubProcessors/<str>/")
        .privileges(redfish::privileges::headProcessor)
        .methods(boost::beast::http::verb::head)(
            std::bind_front(handleSubProcessorThreadHead, std::ref(app)));
    BMCWEB_ROUTE(
        app,
        "/redfish/v1/Systems/<str>/Processors/<str>/SubProcessors/<str>/SubProcessors/<str>/")
        .privileges(redfish::privileges::getProcessor)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& systemName,
                   const std::string& processorId, const std::string& coreId,
                   const std::string& threadId) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp))
        {
            return;
        }
        if (systemName != "system")
        {
            messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                       systemName);
            return;
        }

        getSubProcessorCorePaths(asyncResp, processorId, coreId,
                                 std::bind_front(getSubProcessorThreadData,
                                                 asyncResp, processorId, coreId,
                                                 threadId));
    });
}

} // namespace redfish