#pragma once

#include "absl/strings/substitute.h"
#include "bm_config.h"

#include "app.hpp"
#include "managed_store.hpp"
#include "query.hpp"
#include "registries/privilege_registry.hpp"
#include "utils/sw_utils.hpp"

#include <utils/json_utils.hpp>

#include <filesystem>
#include <fstream>

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

namespace redfish
{

constexpr absl::string_view kPldmServiceName = "xyz.openbmc_project.pldm";
constexpr absl::string_view kPldmObjectPath = "/xyz/openbmc_project/pldm";
constexpr absl::string_view kPldmControlInterface =
    "xyz.openbmc_project.PLDM.control";
constexpr absl::string_view kPldmLoadSingleFileMethod =
    "loadSingleFileAndSyncCache";

std::string biosSettingFilepathFromConfig = BIOS_SETTING_FILE_PATH;

std::string readBiosSettingsIntoBase64(std::string biosSettingBlobPath)
{
    // If the path doesn't exist, set the properties to an empty string
    if (!std::filesystem::exists(biosSettingBlobPath))
    {
        BMCWEB_LOG_ERROR << "the BIOS setting file doesn't exist, path:"
                         << biosSettingBlobPath;
        return {};
    }
    const auto fileSize = std::filesystem::file_size(biosSettingBlobPath);
    if (fileSize == 0)
    {
        BMCWEB_LOG_DEBUG << "the BIOS setting file is empty, path:"
                         << biosSettingBlobPath;
        return {};
    }
    // ManagedFd would be nice but stdplus is not included as DEPENDS in gbmcweb
    std::ifstream ifs(biosSettingBlobPath, std::ios::binary);
    ifs.exceptions(std::ifstream::failbit);
    std::vector<char> fileData(fileSize);
    try
    {
        std::copy(std::istreambuf_iterator<char>(ifs),
                  std::istreambuf_iterator<char>(), fileData.begin());
    }
    catch (std::ios_base::failure& fail)
    {
        BMCWEB_LOG_ERROR << "Failed to read the BIOS setting file";
        return {};
    }
    return crow::utility::base64encode(
        std::string_view(fileData.data(), fileData.size()));
}

inline std::string resourceIdFromNameString(const std::string& name)
{
    // Find out the index of last non digit character(0,1,2,3,4,5,6,7,8,9)
    // assuming the inout has at least one digit so that we can get resource
    // index. For example, system1->1.
    return name.substr(name.find_last_not_of("0123456789") + 1);
}

inline void handleBios(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                       const std::string& systemName, bool multiHost)
{
    // systemId should be empty for single host system.
    std::string systemId =
        multiHost ? resourceIdFromNameString(systemName) : "";

    asyncResp->res.jsonValue["@odata.id"] =
        absl::Substitute("/redfish/v1/Systems/$0/Bios", systemName);
    asyncResp->res.jsonValue["@odata.type"] = "#Bios.v1_1_0.Bios";
    asyncResp->res.jsonValue["Name"] = "BIOS Configuration";
    asyncResp->res.jsonValue["Description"] = "BIOS Configuration Service";
    asyncResp->res.jsonValue["Id"] = "BIOS";
    asyncResp->res.jsonValue["Actions"]["#Bios.ResetBios"] = {
        {"target",
         absl::Substitute("/redfish/v1/Systems/$0/Bios/Actions/Bios.ResetBios",
                          systemName)}};

    // Get the ActiveSoftwareImage and SoftwareImages
    sw_util::populateSoftwareInformation(asyncResp, sw_util::biosPurpose, "",
                                         true);

    // Populated BIOS setting blob
    std::string biosSettingFilepath = biosSettingFilepathFromConfig;
    if (multiHost)
    {
        size_t posHost = biosSettingFilepath.find("host");
        if (posHost == std::string::npos)
        {
            BMCWEB_LOG_DEBUG
                << "The BIOS setting file path template is ill-formated"
                << biosSettingFilepath;
            return;
        }
        // Get index
        int systemIdInt = 0;
        try
        {
            systemIdInt = std::stoi(systemId);
            // system1 -> /run/soc_firmware/host0/vmtppr.cfg
            // system2 -> /run/soc_firmware/host1/vmtppr.cfg
            systemIdInt -= 1;
        }
        catch (const std::exception& ex)
        {
            BMCWEB_LOG_DEBUG << "file to parse systemId " << systemId
                             << ":from string to int, exception:" << ex.what();
            return;
        }

        // insert the index right after "host" i.e. pos + 4
        biosSettingFilepath.insert(posHost + 4, std::to_string(systemIdInt));
    }

    asyncResp->res.jsonValue["Oem"]["Google"]["MemTestBlob"] =
        readBiosSettingsIntoBase64(biosSettingFilepath);
}

/**
 * BiosService class supports handle get method for bios.
 */
inline void
    handleBiosServiceGet(crow::App& app, const crow::Request& req,
                         const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                         const std::string& systemName)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }

    constexpr std::array<std::string_view, 1> systemInterfaces{
        {"xyz.openbmc_project.Inventory.Item.System"}};
    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    managedStore::GetManagedObjectStore()->getSubTreePaths(
        "/", 0, systemInterfaces, requestContext,
        [asyncResp, systemName](const boost::system::error_code& ec,
                                const std::vector<std::string>& objects) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error";
            messages::internalError(asyncResp->res);
            return;
        }

        // If there are less than 2 Item.Systems assume singlehost
        if (objects.size() < 2)
        {
            if (systemName != "system")
            {
                messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                           systemName);
                return;
            }
            handleBios(asyncResp, systemName, false);
            return;
        }

        // Otherwise find system, e.g. system1, system2
        for (const auto& object : objects)
        {
            std::string objectName = object.substr(object.rfind('/') + 1);
            // Found system object
            if (systemName == objectName)
            {
                handleBios(asyncResp, systemName, true);
                return;
            }
        }

        // Could not find system object
        messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                   systemName);
    });
}

inline void handleBiosSettingPatch(
    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
    const std::string& biosSettingFilepath, bool multiHost,
    std::optional<std::string> memTestBlob, int systemId = 0)
{
    asyncResp->res.result(boost::beast::http::status::no_content);

    std::filesystem::path filePath(biosSettingFilepath);
    if (!std::filesystem::exists(filePath.parent_path()))
    {
        BMCWEB_LOG_ERROR
            << "The directory of the BIOS setting file doesn't exist";
        redfish::messages::internalError(asyncResp->res);
        return;
    }

    if (!memTestBlob)
    {
        BMCWEB_LOG_ERROR << "Payload was null";
        redfish::messages::internalError(asyncResp->res);
        return;
    }
    std::string memTestBlobBase64;
    if (crow::utility::base64Decode(memTestBlob.value_or(""),
                                    memTestBlobBase64) == false)
    {
        BMCWEB_LOG_ERROR << "Base64 Decoding unsuccessful";
        redfish::messages::internalError(asyncResp->res);
        return;
    }
    try
    {
        std::ofstream ofs;
        ofs.open(biosSettingFilepath, std::ios::trunc | std::ios::binary);
        ofs.write(reinterpret_cast<char*>(memTestBlobBase64.data()),
                  // Get warning if no cast
                  // " error: conversion to
                  // 'std::streamsize' {aka 'int'} from
                  // 'std::__cxx11::basic_string<char>::size_type' {aka
                  // 'unsigned int'} may change the sign of the result
                  // [-Werror=sign-conversion]"
                  static_cast<int>(memTestBlobBase64.size()));
        ofs.close();
    }
    catch (std::ios_base::failure& fail)
    {
        BMCWEB_LOG_ERROR << "Failed to write the BIOS setting file";
        redfish::messages::internalError(asyncResp->res);
        return;
    }

    // We are using PLDM to transfer the BIOS file out in multi-host machine.
    // Reload the file content is necessary to guarantee the file content in
    // PLDMd cache is up-to-date.
    if (multiHost)
    {
        managedStore::GetManagedObjectStore()
            ->PostDbusCallToIoContextThreadSafe(
                asyncResp->strand_,
                [asyncResp](const boost::system::error_code& ec) {
            if (ec)
            {
                BMCWEB_LOG_ERROR << "DBUS response error: " << ec;
                messages::internalError(asyncResp->res);
                return;
            }
        }, std::string(kPldmServiceName) + std::to_string(systemId),
                std::string(kPldmObjectPath),
                std::string(kPldmControlInterface),
                std::string(kPldmLoadSingleFileMethod),
                static_cast<uint16_t>(BIOS_SETTING_FILE_HANDLE));
    }

    redfish::messages::success(asyncResp->res);
    return;
}

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

    std::optional<std::string> memTestBlob;
    if (!ENABLE_BIOS_PEER_AUTH_BYPASS && !req.peer_authenticated)
    {
        redfish::messages::accessDenied(asyncResp->res, "Bios");
        return;
    }

    if (!redfish::json_util::readJsonPatch(
            req, asyncResp->res, "Oem/Google/MemTestBlob", memTestBlob))
    {
        BMCWEB_LOG_ERROR << "There was no valid patch payload";
        redfish::messages::internalError(asyncResp->res);
        return;
    }

    constexpr std::array<std::string_view, 1> systemInterfaces{
        {"xyz.openbmc_project.Inventory.Item.System"}};
    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    managedStore::GetManagedObjectStore()->getSubTreePaths(
        "/", 0, systemInterfaces, requestContext,
        [asyncResp, systemName,
         memTestBlob](const boost::system::error_code& ec,
                      const std::vector<std::string>& objects) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error";
            messages::internalError(asyncResp->res);
            return;
        }

        std::string biosSettingFilepath = biosSettingFilepathFromConfig;
        // If there are less than 2 Item.Systems assume singlehost
        if (objects.size() < 2)
        {
            if (systemName != "system")
            {
                messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                           systemName);
                return;
            }
            handleBiosSettingPatch(asyncResp, biosSettingFilepath, false,
                                   memTestBlob);
            return;
        }

        // Otherwise find system, e.g. system1, system2
        for (const auto& object : objects)
        {
            std::string objectName = object.substr(object.rfind('/') + 1);
            // Found system object
            if (systemName == objectName)
            {
                // Format the actual file path based on systemName
                std::string systemId = resourceIdFromNameString(systemName);
                size_t posHost = biosSettingFilepath.find("host");
                if (posHost == std::string::npos)
                {
                    BMCWEB_LOG_DEBUG
                        << "The BIOS setting file path template is invalid"
                        << biosSettingFilepath;
                    messages::internalError(asyncResp->res);
                    return;
                }
                // Get index
                int systemIdInt = 0;
                try
                {
                    systemIdInt = std::stoi(systemId);
                    // system1 -> /run/soc_firmware/host0/vmtppr.cfg
                    // system2 -> /run/soc_firmware/host1/vmtppr.cfg
                    systemIdInt -= 1;
                }
                catch (const std::exception& ex)
                {
                    BMCWEB_LOG_DEBUG
                        << "file to parse systemId " << systemId
                        << ":from string to int, exception:" << ex.what();
                    messages::internalError(asyncResp->res);
                    return;
                }

                // insert the index right after "host" i.e. pos + 4
                biosSettingFilepath.insert(posHost + 4,
                                           std::to_string(systemIdInt));

                handleBiosSettingPatch(asyncResp, biosSettingFilepath, true,
                                       memTestBlob, systemIdInt);
                return;
            }
        }

        // Could not find system object
        messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                   systemName);
    });
}

inline void requestRoutesBiosService(App& app)
{
    BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Bios/")
        .privileges(redfish::privileges::getBios)
        .methods(boost::beast::http::verb::get)(
            std::bind_front(handleBiosServiceGet, std::ref(app)));

    BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Bios/")
        .privileges(redfish::privileges::patchBios)
        .methods(boost::beast::http::verb::patch)(
            std::bind_front(patchBiosSettings, std::ref(app)));
}

/**
 * BiosReset class supports handle POST method for Reset bios.
 * The class retrieves and sends data directly to D-Bus.
 *
 * Function handles POST method request.
 * Analyzes POST body message before sends Reset request data to D-Bus.
 */
inline void
    handleBiosResetPost(crow::App& app, const crow::Request& req,
                        const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                        const std::string& systemName)
{
    if (!redfish::setUpRedfishRoute(app, req, asyncResp))
    {
        return;
    }

    if (systemName != "system")
    {
        messages::resourceNotFound(asyncResp->res, "ComputerSystem",
                                   systemName);
        return;
    }

    managedStore::GetManagedObjectStore()->PostDbusCallToIoContextThreadSafe(
        asyncResp->strand_,
        [asyncResp](const boost::system::error_code& ec) {
        if (ec)
        {
            BMCWEB_LOG_ERROR << "Failed to reset bios: " << ec;
            messages::internalError(asyncResp->res);
            return;
        }
    }, "org.open_power.Software.Host.Updater", "/xyz/openbmc_project/software",
        "xyz.openbmc_project.Common.FactoryReset", "Reset");
}

inline void requestRoutesBiosReset(App& app)
{
    BMCWEB_ROUTE(app, "/redfish/v1/Systems/<str>/Bios/Actions/Bios.ResetBios/")
        .privileges(redfish::privileges::postBios)
        .methods(boost::beast::http::verb::post)(
            std::bind_front(handleBiosResetPost, std::ref(app)));
}

} // namespace redfish