#include "inventory_manager.hpp"

#include "common/utils.hpp"
#include "xyz/openbmc_project/Software/Version/server.hpp"

#include <libpldm/firmware_update.h>

#include <phosphor-logging/lg2.hpp>

#include <functional>

PHOSPHOR_LOG2_USING;

namespace pldm
{
namespace fw_update
{
void InventoryManager::discoverFDs(const std::vector<mctp_eid_t>& eids,
                                   const int retriesLeft)
{
    for (const auto& eid : eids)
    {
        auto instanceIdResult = instanceIdDb.next(eid);
        if (!instanceIdResult)
        {
            error("Instance ID allocation failed for EID {EID}", "EID",
                  unsigned(eid));
            throw pldm::InstanceIdError(instanceIdResult.error());
        }
        auto instanceId = instanceIdResult.value();
        Request requestMsg(
            sizeof(pldm_msg_hdr) + PLDM_QUERY_DEVICE_IDENTIFIERS_REQ_BYTES);
        auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
        auto rc = encode_query_device_identifiers_req(
            instanceId, PLDM_QUERY_DEVICE_IDENTIFIERS_REQ_BYTES, request);
        if (rc)
        {
            instanceIdDb.free(eid, instanceId);
            error(
                "encode_query_device_identifiers_req failed, EID={EID}, RC = {RC}",
                "EID", unsigned(eid), "RC", rc);
            continue;
        }

        rc = handler.registerRequest(
            eid, instanceId, PLDM_FWUP, PLDM_QUERY_DEVICE_IDENTIFIERS,
            std::move(requestMsg),
            std::move(std::bind_front(&InventoryManager::queryDeviceIdentifiers,
                                      this, retriesLeft)));
        if (rc)
        {
            error(
                "Failed to send QueryDeviceIdentifiers request, EID={EID}, RC = {RC}",
                "EID", unsigned(eid), "RC", rc);
        }
        else
        {
            info(
                "Sent QueryDeviceIdentifiers request, EID={EID}, retries remaining: {RETRY}",
                "EID", unsigned(eid), "RETRY", unsigned(retriesLeft));
        }
    }
}

void InventoryManager::queryDeviceIdentifiers(
    const int retriesLeft, mctp_eid_t eid, const pldm_msg* response,
    size_t respMsgLen)
{
    if (response == nullptr || !respMsgLen)
    {
        if (retriesLeft > 0)
        {
            error("No response received for QueryDeviceIdentifiers, EID={EID}. "
                  "We really want this. Retries remaining: {RETRY}",
                  "EID", unsigned(eid), "RETRY", unsigned(retriesLeft));
            discoverFDs({eid}, retriesLeft - 1);
        }
        else
        {
            error(
                "No response received for QueryDeviceIdentifiers, EID={EID}. No more retries remaining. Womp womp.",
                "EID", unsigned(eid));
        }
        return;
    }

    uint8_t completionCode = PLDM_SUCCESS;
    uint32_t deviceIdentifiersLen = 0;
    uint8_t descriptorCount = 0;
    uint8_t* descriptorPtr = nullptr;

    auto rc = decode_query_device_identifiers_resp(
        response, respMsgLen, &completionCode, &deviceIdentifiersLen,
        &descriptorCount, &descriptorPtr);
    if (rc)
    {
        error(
            "Decoding QueryDeviceIdentifiers response failed, EID={EID}, RC = {RC}",
            "EID", unsigned(eid), "RC", rc);
        return;
    }

    if (completionCode)
    {
        error(
            "QueryDeviceIdentifiers response failed with error completion code, EID={EID}, CC = {CC}",
            "EID", unsigned(eid), "CC", unsigned(completionCode));
        return;
    }

    Descriptors descriptors{};
    while (descriptorCount-- && (deviceIdentifiersLen > 0))
    {
        uint16_t descriptorType = 0;
        variable_field descriptorData{};

        rc = decode_descriptor_type_length_value(
            descriptorPtr, deviceIdentifiersLen, &descriptorType,
            &descriptorData);
        if (rc)
        {
            error(
                "Decoding descriptor type, length and value failed, EID={EID}, RC = {RC}",
                "EID", unsigned(eid), "RC", rc);
            return;
        }

        if (descriptorType != PLDM_FWUP_VENDOR_DEFINED)
        {
            std::vector<uint8_t> descData(
                descriptorData.ptr, descriptorData.ptr + descriptorData.length);
            descriptors.emplace(descriptorType, std::move(descData));
        }
        else
        {
            uint8_t descriptorTitleStrType = 0;
            variable_field descriptorTitleStr{};
            variable_field vendorDefinedDescriptorData{};

            rc = decode_vendor_defined_descriptor_value(
                descriptorData.ptr, descriptorData.length,
                &descriptorTitleStrType, &descriptorTitleStr,
                &vendorDefinedDescriptorData);
            if (rc)
            {
                error(
                    "Decoding Vendor-defined descriptor value failed, EID={EID}, RC = {RC}",
                    "EID", unsigned(eid), "RC", rc);
                return;
            }

            auto vendorDefinedDescriptorTitleStr =
                utils::toString(descriptorTitleStr);
            std::vector<uint8_t> vendorDescData(
                vendorDefinedDescriptorData.ptr,
                vendorDefinedDescriptorData.ptr +
                    vendorDefinedDescriptorData.length);
            descriptors.emplace(descriptorType,
                                std::make_tuple(vendorDefinedDescriptorTitleStr,
                                                vendorDescData));
        }
        auto nextDescriptorOffset =
            sizeof(pldm_descriptor_tlv().descriptor_type) +
            sizeof(pldm_descriptor_tlv().descriptor_length) +
            descriptorData.length;
        descriptorPtr += nextDescriptorOffset;
        deviceIdentifiersLen -= nextDescriptorOffset;
    }

    info("EID: {EID} Descriptors:", "EID", unsigned(eid));
    for (const auto& [descriptor_type, descriptor] : descriptors)
    {
        if (std::holds_alternative<DescriptorData>(descriptor))
        {
            const auto desc = std::get<DescriptorData>(descriptor);
            std::stringstream ss;
            ss << std::hex << std::setfill('0');
            for (const auto& byte : desc)
            {
                ss << std::setw(2) << static_cast<int>(byte);
            }
            info("Descriptor type: {TYPE}, descriptor: {DESC}", "TYPE",
                 descriptor_type, "DESC", ss.str());
        }
        else
        {
            const auto [desc_title, desc] =
                std::get<VendorDefinedDescriptorInfo>(descriptor);
            std::stringstream ss;
            ss << std::hex << std::setfill('0');
            for (const auto& byte : desc)
            {
                ss << std::setw(2) << static_cast<int>(byte);
            }
            info("Descriptor type: {TYPE}, descriptor: {DESC_TITLE} {DESC}",
                 "TYPE", descriptor_type, "DESC_TITLE", desc_title, "DESC",
                 ss.str());
        }
    }
    descriptorMap.emplace(eid, std::move(descriptors));

    // Send GetFirmwareParameters request
    sendGetFirmwareParametersRequest(retriesLeft, eid);
}

void InventoryManager::sendGetFirmwareParametersRequest(const int retriesLeft,
                                                        mctp_eid_t eid)
{
    auto instanceIdResult = instanceIdDb.next(eid);
    if (!instanceIdResult)
    {
        error("Instance ID allocation failed for EID {EID}", "EID",
              unsigned(eid));
        throw pldm::InstanceIdError(instanceIdResult.error());
    }
    auto instanceId = instanceIdResult.value();
    Request requestMsg(
        sizeof(pldm_msg_hdr) + PLDM_GET_FIRMWARE_PARAMETERS_REQ_BYTES);
    auto request = reinterpret_cast<pldm_msg*>(requestMsg.data());
    auto rc = encode_get_firmware_parameters_req(
        instanceId, PLDM_GET_FIRMWARE_PARAMETERS_REQ_BYTES, request);
    if (rc)
    {
        instanceIdDb.free(eid, instanceId);
        error("encode_get_firmware_parameters_req failed, EID={EID}, RC = {RC}",
              "EID", unsigned(eid), "RC", rc);
        return;
    }

    rc = handler.registerRequest(
        eid, instanceId, PLDM_FWUP, PLDM_GET_FIRMWARE_PARAMETERS,
        std::move(requestMsg),
        std::move(std::bind_front(&InventoryManager::getFirmwareParameters,
                                  this, retriesLeft)));
    if (rc)
    {
        error(
            "Failed to send GetFirmwareParameters request, EID={EID}, RC = {RC}",
            "EID", unsigned(eid), "RC", rc);
    }
    else
    {
        info(
            "Sent GetFirmwareParameters request, EID={EID}, retries remaining: {RETRY}",
            "EID", unsigned(eid), "RETRY", unsigned(retriesLeft));
    }
}

void InventoryManager::getFirmwareParameters(
    const int retriesLeft, mctp_eid_t eid, const pldm_msg* response,
    size_t respMsgLen)
{
    if (response == nullptr || !respMsgLen)
    {
        if (retriesLeft > 0)
        {
            error("No response received for GetFirmwareParameters, EID={EID}. "
                  "We really want this. Retries remaining: {RETRY}",
                  "EID", unsigned(eid), "RETRY", unsigned(retriesLeft));
            sendGetFirmwareParametersRequest(retriesLeft - 1, eid);
        }
        else
        {
            error(
                "No response received for GetFirmwareParameters, EID={EID}. No more retries remaining. Womp womp.",
                "EID", unsigned(eid));
        }
        descriptorMap.erase(eid);
        return;
    }

    pldm_get_firmware_parameters_resp fwParams{};
    variable_field activeCompImageSetVerStr{};
    variable_field pendingCompImageSetVerStr{};
    variable_field compParamTable{};

    auto rc = decode_get_firmware_parameters_resp(
        response, respMsgLen, &fwParams, &activeCompImageSetVerStr,
        &pendingCompImageSetVerStr, &compParamTable);
    if (rc)
    {
        error(
            "Decoding GetFirmwareParameters response failed, EID={EID}, RC = {RC}",
            "EID", unsigned(eid), "RC", rc);
        return;
    }

    if (fwParams.completion_code)
    {
        error(
            "GetFirmwareParameters response failed with error completion code, EID={EID}, CC = {CC}",
            "EID", unsigned(eid), "CC", unsigned(fwParams.completion_code));
        return;
    }

    auto compParamPtr = compParamTable.ptr;
    auto compParamTableLen = compParamTable.length;
    pldm_component_parameter_entry compEntry{};
    variable_field activeCompVerStr{};
    variable_field pendingCompVerStr{};

    ComponentInfo componentInfo{};
    while (fwParams.comp_count-- && (compParamTableLen > 0))
    {
        auto rc = decode_get_firmware_parameters_resp_comp_entry(
            compParamPtr, compParamTableLen, &compEntry, &activeCompVerStr,
            &pendingCompVerStr);
        if (rc)
        {
            error(
                "Decoding component parameter table entry failed, EID={EID}, RC = {RC}",
                "EID", unsigned(eid), "RC", rc);
            return;
        }

        auto compClassification = compEntry.comp_classification;
        auto compIdentifier = compEntry.comp_identifier;
        componentInfo.emplace(
            std::make_pair(compClassification, compIdentifier),
            compEntry.comp_classification_index);
        compParamPtr += sizeof(pldm_component_parameter_entry) +
                        activeCompVerStr.length + pendingCompVerStr.length;
        compParamTableLen -= sizeof(pldm_component_parameter_entry) +
                             activeCompVerStr.length + pendingCompVerStr.length;
    }
    info("EID: {EID} Components:", "EID", unsigned(eid));
    for (const auto& [comp_key, comp_class_index] : componentInfo)
    {
        const auto& [comp_class, comp_identifier] = comp_key;
        info(
            "Classification: {CLASS} Identifier: {IDENT} Classification index: {CLASS_INDEX}",
            "CLASS", unsigned(comp_class), "IDENT", unsigned(comp_identifier),
            "CLASS_INDEX", unsigned(comp_class_index));
    }
    componentInfoMap.emplace(eid, std::move(componentInfo));
}

} // namespace fw_update

} // namespace pldm