#pragma once

#include "app.hpp"
#include "async_resp.hpp"
#include "dbus_utility.hpp"
#include "error_messages.hpp"
#include "managed_store.hpp"
#include "query.hpp"
#include "utils/chassis_utils.hpp"
#include "utils/collection.hpp"
#include "utils/dbus_utils.hpp"
#include "utils/hex_utils.hpp"
#include "utils/json_utils.hpp"

#include <boost/system/error_code.hpp>
#include <nlohmann/json.hpp>

#include <array>
#include <regex>
#include <string_view>
#include <vector>

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

namespace crow
{
namespace google_api
{

inline void
    handleGoogleV1Get(App& app, const crow::Request& req,
                      const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }
    asyncResp->res.jsonValue["@odata.type"] =
        "#GoogleServiceRoot.v1_0_0.GoogleServiceRoot";
    asyncResp->res.jsonValue["@odata.id"] = "/google/v1";
    asyncResp->res.jsonValue["Id"] = "Google Rest RootService";
    asyncResp->res.jsonValue["Name"] = "Google Service Root";
    asyncResp->res.jsonValue["Version"] = "1.0.0";
    asyncResp->res.jsonValue["RootOfTrustCollection"]["@odata.id"] =
        "/google/v1/RootOfTrustCollection";
    asyncResp->res.jsonValue["NVMe"]["@odata.id"] = "/google/v1/NVMe";
}

inline void handleRootOfTrustCollectionGet(
    App& app, const crow::Request& req,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }
    asyncResp->res.jsonValue["@odata.id"] = "/google/v1/RootOfTrustCollection";
    asyncResp->res.jsonValue["@odata.type"] =
        "#RootOfTrustCollection.RootOfTrustCollection";
    const std::array<std::string_view, 1> interfaces{
        "xyz.openbmc_project.Control.Hoth"};
    redfish::collection_util::getCollectionMembers(
        asyncResp, boost::urls::url("/google/v1/RootOfTrustCollection"),
        interfaces, "/xyz/openbmc_project");
}

// Helper struct to identify a resolved D-Bus object interface
struct ResolvedEntity
{
    std::string id;
    std::string service;
    std::string object;
    std::string interface;
};

using ResolvedEntityHandler = std::function<void(
    const std::string&, const std::shared_ptr<bmcweb::AsyncResp>&,
    const ResolvedEntity&)>;

inline void hothGetSubtreeCallback(
    const std::string& command,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& rotId, const ResolvedEntityHandler& entityHandler,
    const boost::system::error_code& ec,
    const dbus::utility::MapperGetSubTreeResponse& subtree)
{
    if (ec)
    {
        redfish::messages::internalError(asyncResp->res);
        return;
    }
    for (const auto& [path, services] : subtree)
    {
        sdbusplus::message::object_path objPath(path);
        if (objPath.filename() != rotId || services.empty())
        {
            continue;
        }

        ResolvedEntity resolvedEntity = {
            .id = rotId,
            .service = services[0].first,
            .object = path,
            .interface = "xyz.openbmc_project.Control.Hoth"};
        entityHandler(command, asyncResp, resolvedEntity);
        return;
    }

    // Couldn't find an object with that name.  return an error
    redfish::messages::resourceNotFound(asyncResp->res, "RootOfTrust", rotId);
}

inline void resolveRoT(const std::string& command,
                       const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                       const std::string& rotId,
                       ResolvedEntityHandler&& entityHandler)
{
    constexpr std::array<std::string_view, 1> hothIfaces = {
        "xyz.openbmc_project.Control.Hoth"};
    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    managedStore::GetManagedObjectStore()->getSubTree(
        "/xyz/openbmc_project", 0, hothIfaces, requestContext,
        [command, asyncResp, rotId,
         entityHandler{std::forward<ResolvedEntityHandler>(entityHandler)}](
            const boost::system::error_code& ec,
            const dbus::utility::MapperGetSubTreeResponse& subtree) {
        hothGetSubtreeCallback(command, asyncResp, rotId, entityHandler, ec,
                               subtree);
    });
}

inline void populateRootOfTrustState(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const dbus::utility::DBusPropertiesMap& properties)
{
    const uint64_t* authRecordCapabilities = nullptr;
    const uint32_t* bootloaderUpdateFailureCode = nullptr;
    const uint32_t* firmwareUpdateFailedMinor = nullptr;
    const uint32_t* firmwareUpdateFailureCode = nullptr;
    const uint32_t* payloadConfirmFailureCode = nullptr;
    const uint32_t* payloadUpdateFailureCode = nullptr;
    const uint32_t* resetFlags = nullptr;
    const uint32_t* roInfoStrikes = nullptr;
    const uint32_t* rwInfoStrikes = nullptr;
    const uint64_t* upTime = nullptr;
    const bool* hasPersistentPanicInfo = nullptr;
    const bool* hasValidAuthRecord = nullptr;

    const bool success = sdbusplus::unpackPropertiesNoThrow(
        redfish::dbus_utils::UnpackErrorPrinter(), properties,
        "BootloaderUpdateFailureCode", bootloaderUpdateFailureCode,
        "FirmwareUpdateFailedMinor", firmwareUpdateFailedMinor,
        "FirmwareUpdateFailureCode", firmwareUpdateFailureCode,
        "PayloadConfirmFailureCode", payloadConfirmFailureCode,
        "PayloadUpdateFailureCode", payloadUpdateFailureCode, "ResetFlags",
        resetFlags, "RoInfoStrikes", roInfoStrikes, "RwInfoStrikes",
        rwInfoStrikes, "UpTime", upTime, "HasPersistentPanicInfo",
        hasPersistentPanicInfo, "HasValidAuthRecord", hasValidAuthRecord,
        "AuthRecordCapabilities", authRecordCapabilities);

    if (!success)
    {
        BMCWEB_LOG_ERROR << "Failed to populate RootOfTrustState";
        redfish::messages::internalError(asyncResp->res);
        return;
    }

    if (bootloaderUpdateFailureCode != nullptr)
    {
        asyncResp->res
            .jsonValue["Status"]["Oem"]["BootloaderUpdateFailureCode"] =
            *bootloaderUpdateFailureCode;
    }
    if (firmwareUpdateFailedMinor != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["FirmwareUpdateFailedMinor"] =
            *firmwareUpdateFailedMinor;
    }
    if (firmwareUpdateFailureCode != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["FirmwareUpdateFailureCode"] =
            *firmwareUpdateFailureCode;
    }
    if (resetFlags != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["ResetFlags"] = *resetFlags;
    }
    if (roInfoStrikes != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["RoInfoStrikes"] =
            *roInfoStrikes;
    }
    if (rwInfoStrikes != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["RwInfoStrikes"] =
            *rwInfoStrikes;
    }
    if (upTime != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["UpTime"] = *upTime;
    }
    if (hasPersistentPanicInfo != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["HasPersistentPanicInfo"] =
            *hasPersistentPanicInfo;
    }

    if (payloadConfirmFailureCode != nullptr)
    {
        asyncResp->res
            .jsonValue["Status"]["Oem"]["Payload"]["ConfirmFailureCode"] =
            *payloadConfirmFailureCode;
    }
    if (payloadUpdateFailureCode != nullptr)
    {
        asyncResp->res
            .jsonValue["Status"]["Oem"]["Payload"]["UpdateFailureCode"] =
            *payloadUpdateFailureCode;
    }
    if (hasValidAuthRecord != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["Authorization"]["Valid"] =
            *hasValidAuthRecord;
    }
    if (authRecordCapabilities != nullptr)
    {
        asyncResp->res.jsonValue["Status"]["Oem"]["Authorization"]["Capabilities"] =
            *authRecordCapabilities;
    }
}

inline void populateRootOfTrustEntity(
    const std::string& /*unused*/,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const ResolvedEntity& resolvedEntity)
{
    asyncResp->res.jsonValue["@odata.type"] = "#RootOfTrust.v1_0_0.RootOfTrust";
    asyncResp->res.jsonValue["@odata.id"] = crow::utility::urlFromPieces(
        "google", "v1", "RootOfTrustCollection", resolvedEntity.id);

    asyncResp->res.jsonValue["Status"]["State"] = "Enabled";
    asyncResp->res.jsonValue["Id"] = resolvedEntity.id;
    // Need to fix this later to a stabler property.
    asyncResp->res.jsonValue["Name"] = resolvedEntity.id;
    asyncResp->res.jsonValue["Description"] = "Google Root Of Trust";
    asyncResp->res.jsonValue["Actions"]["#RootOfTrust.SendCommand"]["target"] =
        "/google/v1/RootOfTrustCollection/" + resolvedEntity.id +
        "/Actions/RootOfTrust.SendCommand";

    asyncResp->res.jsonValue["Location"]["PartLocation"]["ServiceLabel"] =
        resolvedEntity.id;
    asyncResp->res.jsonValue["Location"]["PartLocation"]["LocationType"] =
        "Embedded";

    // Only link to RW firmware inventory.
    //
    // For USB-Hoth, FirmwareInventory URI is "hoth_${hothId}_rw".
    // For non-USB Hoth, FirmwareInventory URI is "hoth_rw".
    std::string hothFirmware = resolvedEntity.id == "Hoth"
                                   ? "hoth_rw"
                                   : "hoth_" + resolvedEntity.id + "_rw";
    asyncResp->res.jsonValue["Links"]["ActiveSoftwareImage"]["@odata.id"] =
        "/redfish/v1/UpdateService/FirmwareInventory/" + hothFirmware;

    // Temporary hack to get the Hoth firmware family as "Model", by stripping
    // the USB suffix from hothId.
    //
    // Non-USB Hoth has resolvedEntity.id="Hoth" as model name.
    //
    // Once we have SoftwareInventory 1.9.0 supported everywhere, the firmware
    // family should reside there and the model here should be the chip's part
    // number.
    static std::regex hothIdSuffixRe("_[0-9_]+$");
    asyncResp->res.jsonValue["Model"] =
        std::regex_replace(resolvedEntity.id, hothIdSuffixRe, "");

    // Get Hoth properties from Dbus.
    managedStore::ManagedObjectStoreContext context(asyncResp);
    managedStore::GetManagedObjectStore()->getAllProperties(
        resolvedEntity.service, resolvedEntity.object,
        "xyz.openbmc_project.Control.Hoth.State", context,
        [asyncResp](const boost::system::error_code ec2,
                    const dbus::utility::DBusPropertiesMap& properties) {
        if (ec2)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error " << ec2;
            return;
        }
        populateRootOfTrustState(asyncResp, properties);
    });

    // Get Chassis Link for Devpath from DBus
    managedStore::ManagedObjectStoreContext context2(asyncResp);
    managedStore::GetManagedObjectStore()->getAssociatedSubTreePaths(
        sdbusplus::message::object_path(resolvedEntity.object) / "contained_by",
        sdbusplus::message::object_path("/xyz/openbmc_project/inventory"), 0,
        redfish::chassis_utils::chassisInterfaces, context2,
        [asyncResp](
            const boost::system::error_code& ec,
            const dbus::utility::MapperGetSubTreePathsResponse& chassisPaths) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
            return;
        }

        if (!chassisPaths.empty())
        {
            asyncResp->res.jsonValue["RelatedItem"] = nlohmann::json::array();
        }
        for (const auto& str : chassisPaths)
        {
            std::filesystem::path chassisPath(str);
            nlohmann::json::object_t relatedChassis;
            relatedChassis["@odata.id"] = crow::utility::urlFromPieces(
                "redfish", "v1", "Chassis", chassisPath.filename().c_str());
            asyncResp->res.jsonValue["RelatedItem"].emplace_back(
                relatedChassis);

            // Get PartLocationContext from Chassis LocationCode interface
            managedStore::ManagedObjectStoreContext context(asyncResp);
            redfish::dbus_utils::getProperty<std::string>(
                "xyz.openbmc_project.EntityManager", chassisPath.c_str(),
                "xyz.openbmc_project.Inventory.Decorator.LocationCode",
                "LocationCode", context,
                [asyncResp](const boost::system::error_code ec,
                            const std::string& locationCode) {
                if (ec)
                {
                    BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
                    return;
                }
                asyncResp->res.jsonValue["Location"]["PartLocationContext"] =
                    locationCode;
            });
        }
    }

    );
}

inline void
    handleRootOfTrustGet(App& app, const crow::Request& req,
                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                         const std::string& param)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }
    std::string emptyCommand;
    resolveRoT(emptyCommand, asyncResp, param, populateRootOfTrustEntity);
}

inline void
    invocationCallback(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                       const boost::system::error_code& ec,
                       const std::vector<uint8_t>& responseBytes)
{
    if (ec)
    {
        BMCWEB_LOG_ERROR << "RootOfTrust.Actions.SendCommand failed: "
                         << ec.message();
        redfish::messages::internalError(asyncResp->res);
        return;
    }

    asyncResp->res.jsonValue["CommandResponse"] =
        bytesToHexString(responseBytes);
}

inline void
    invokeRoTCommand(const std::string& command,
                     const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                     const ResolvedEntity& resolvedEntity)
{
    std::vector<uint8_t> bytes = hexStringToBytes(command);
    if (bytes.empty())
    {
        BMCWEB_LOG_DEBUG << "Invalid command: " << command;
        redfish::messages::actionParameterValueTypeError(command, "Command",
                                                         "SendCommand");
        return;
    }

    managedStore::GetManagedObjectStore()->PostDbusCallToIoContextThreadSafe(
        asyncResp->strand_,
        [asyncResp{asyncResp}](const boost::system::error_code& ec,
                               const std::vector<uint8_t>& responseBytes) {
        invocationCallback(asyncResp, ec, responseBytes);
    },
        resolvedEntity.service, resolvedEntity.object, resolvedEntity.interface,
        "SendHostCommand", bytes);
}

inline void handleRoTSendCommandPost(
    App& app, const crow::Request& request,
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& rotId)
{
    if (!redfish::setUpRedfishRoute(app, request, asyncResp))
    {
        return;
    }
    std::string command;
    if (!redfish::json_util::readJsonAction(request, asyncResp->res, "Command",
                                            command))
    {
        BMCWEB_LOG_DEBUG << "Missing property Command.";
        redfish::messages::actionParameterMissing(asyncResp->res, "SendCommand",
                                                  "Command");
        return;
    }

    resolveRoT(command, asyncResp, rotId, invokeRoTCommand);
}

inline void requestRoutes(App& app)
{
    BMCWEB_ROUTE(app, "/google/v1/")
        .methods(boost::beast::http::verb::get)(
            std::bind_front(handleGoogleV1Get, std::ref(app)));

    BMCWEB_ROUTE(app, "/google/v1/RootOfTrustCollection/")
        .privileges({{"ConfigureManager"}})
        .methods(boost::beast::http::verb::get)(
            std::bind_front(handleRootOfTrustCollectionGet, std::ref(app)));

    BMCWEB_ROUTE(app, "/google/v1/RootOfTrustCollection/<str>/")
        .privileges({{"ConfigureManager"}})
        .methods(boost::beast::http::verb::get)(
            std::bind_front(handleRootOfTrustGet, std::ref(app)));

    BMCWEB_ROUTE(
        app,
        "/google/v1/RootOfTrustCollection/<str>/Actions/RootOfTrust.SendCommand/")
        .privileges({{"ConfigureManager"}})
        .methods(boost::beast::http::verb::post)(
            std::bind_front(handleRoTSendCommandPost, std::ref(app)));
}

} // namespace google_api
} // namespace crow