#pragma once

#include "managed_store_types.hpp"

#include <app.hpp>
#include <registries/privilege_registry.hpp>
#include <utils/chassis_utils.hpp>
#include <utils/json_utils.hpp>

namespace redfish
{

static constexpr const std::array<std::string_view, 1> fanInterfaces = {
    "xyz.openbmc_project.Configuration.Fan"};
static constexpr const std::array<std::string_view, 1> sensorInterfaces = {
    "xyz.openbmc_project.Sensor.Value"};

inline void
    getFanSensorValue(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                      const std::string& chassisId,
                      const std::string& sensorName,
                      const std::string& sensorType)
{
    if (sensorType != "fan_tach" && sensorType != "fan_pwm")
    {
        BMCWEB_LOG_DEBUG << "Unsupported sensor type";
        messages::internalError(asyncResp->res);
        return;
    }
    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    auto getFanSensorsHandler =
        [asyncResp, chassisId, sensorName, sensorType, requestContext](
            const boost::system::error_code ec,
            const std::vector<std::pair<
                std::string,
                std::vector<std::pair<std::string, std::vector<std::string>>>>>&
                sensorsubtree) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "D-Bus response error on GetSubTree " << ec;
            messages::internalError(asyncResp->res);
            return;
        }

        for (const auto& [objectPath, serviceNames] : sensorsubtree)
        {
            if (objectPath.empty() || serviceNames.size() != 1)
            {
                BMCWEB_LOG_DEBUG << "Error getting Fan D-Bus object!";
                messages::internalError(asyncResp->res);
                return;
            }
            sdbusplus::message::object_path path(objectPath);
            const std::string& leaf = path.filename();
            if (leaf.empty())
            {
                continue;
            }
            if (leaf != sensorName)
            {
                continue;
            }

            const std::string& connectionName = serviceNames[0].first;
            const std::string& tempPath = objectPath;
            auto getAssociationHandler =
                [asyncResp, tempPath, connectionName, chassisId, sensorName,
                 sensorType,
                 requestContext](const boost::system::error_code ec2,
                                 const std::vector<std::string>& resp) {
                BMCWEB_LOG_DEBUG << "Getting chassis association for sensor "
                                 << sensorName;
                if (ec2)
                {
                    BMCWEB_LOG_DEBUG
                        << "Error getting chassis association for the sensor!";
                    messages::internalError(asyncResp->res);
                    return;
                }
                if (resp.size() != 1)
                {
                    BMCWEB_LOG_DEBUG
                        << "The number of associated chassis should be 1";
                    messages::internalError(asyncResp->res);
                    return;
                }
                sdbusplus::message::object_path path2(resp[0]);
                std::string leaf2 = path2.filename();
                if (leaf2 != chassisId)
                {
                    BMCWEB_LOG_DEBUG
                        << "The sensor doesn't belong to the chassis "
                        << chassisId;
                    messages::internalError(asyncResp->res);
                    return;
                }
                auto getFanPropertyHandler =
                    [asyncResp, chassisId, sensorName,
                     sensorType](const boost::system::error_code ec3,
                                 const double& resp2) {
                    if (ec3)
                    {
                        BMCWEB_LOG_DEBUG
                            << "Error getting sensor value for sensor:"
                            << sensorName;
                        messages::internalError(asyncResp->res);
                        return;
                    }
                    if (sensorType == "fan_pwm")
                    {
                        asyncResp->res
                            .jsonValue["SpeedPercent"]["DataSourceUri"] =
                            std::string("/redfish/v1/Chassis/")
                                .append(chassisId)
                                .append("/Sensors/")
                                .append("fanpwm_" + sensorName)
                                .append("/");
                        asyncResp->res.jsonValue["SpeedPercent"]["Reading"] =
                            resp2;
                    }
                    else
                    {
                        asyncResp->res.jsonValue["SpeedPercent"]["SpeedRPM"] =
                            resp2;
                    }
                };
                dbus_utils::getProperty<double>(
                    connectionName, tempPath,
                    "xyz.openbmc_project.Sensor.Value", "Value", requestContext,
                    getFanPropertyHandler);
            };
            dbus_utils::getProperty<std::vector<std::string>>(
                "xyz.openbmc_project.ObjectMapper", tempPath + "/chassis",
                "xyz.openbmc_project.Association", "endpoints", requestContext,
                getAssociationHandler);
        }
    };
    managedStore::managedObjectStore->getSubTree(
        "/xyz/openbmc_project/sensors", 0, sensorInterfaces, requestContext,
        getFanSensorsHandler);
}

inline void
    fillFanProperties(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                      const boost::system::error_code ec,
                      const dbus::utility::DBusPropertiesMap& properties,
                      const std::string& chassisId)
{
    if (ec)
    {
        BMCWEB_LOG_DEBUG << "DBUS response error " << ec;
        messages::internalError(asyncResp->res);
        return;
    }
    for (const auto& [propKey, propVariant] : properties)
    {
        if (propKey == "HotPluggable")
        {
            const bool* hotPluggable = std::get_if<bool>(&propVariant);
            if (hotPluggable == nullptr)
            {
                messages::internalError(asyncResp->res);
                return;
            }
            asyncResp->res.jsonValue["HotPluggable"] = *hotPluggable;
        }
        else if (propKey == "LocationType")
        {
            const std::string* locationType =
                std::get_if<std::string>(&propVariant);
            if (locationType == nullptr)
            {
                messages::internalError(asyncResp->res);
                return;
            }
            asyncResp->res
                .jsonValue["Location"]["PartLocation"]["LocationType"] =
                *locationType;
        }
        else if (propKey == "ServiceLabel")
        {
            const std::string* serviceLabel =
                std::get_if<std::string>(&propVariant);
            if (serviceLabel == nullptr)
            {
                messages::internalError(asyncResp->res);
                return;
            }
            asyncResp->res
                .jsonValue["Location"]["PartLocation"]["ServiceLabel"] =
                *serviceLabel;
        }
        else if (propKey == "TachSensor")
        {
            const std::string* tachSensor =
                std::get_if<std::string>(&propVariant);
            if (tachSensor == nullptr)
            {
                messages::internalError(asyncResp->res);
                return;
            }
            getFanSensorValue(asyncResp, chassisId, *tachSensor, "fan_tach");
        }
        else if (propKey == "PWMSensor")
        {
            const std::string* pwmSensor =
                std::get_if<std::string>(&propVariant);
            if (pwmSensor == nullptr)
            {
                messages::internalError(asyncResp->res);
                return;
            }
            getFanSensorValue(asyncResp, chassisId, *pwmSensor, "fan_pwm");
        }
    }
}

inline void
    getFanProperties(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                     const std::string& fanObjectPath,
                     const dbus::utility::MapperServiceMap& serviceMap,
                     const std::string& chassisId)
{
    BMCWEB_LOG_DEBUG << "Get Properties for Fan " << fanObjectPath;
    for (const auto& [service, interfaces] : serviceMap)
    {
        for (const auto& interface : interfaces)
        {
            if (interface != fanInterfaces[0])
            {
                continue;
            }

            crow::connections::systemBus->async_method_call(
                [asyncResp, chassisId](
                    const boost::system::error_code ec,
                    const dbus::utility::DBusPropertiesMap& properties) {
                fillFanProperties(asyncResp, ec, properties, chassisId);
                },
                service, fanObjectPath, "org.freedesktop.DBus.Properties",
                "GetAll", interface);
        }
    }
}

inline void getValidFan(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                        const std::string& chassisId)
{
    BMCWEB_LOG_DEBUG << "Get fan list associated to chassis = " << chassisId;
    asyncResp->res.jsonValue["@odata.type"] = "#FanCollection.FanCollection";
    asyncResp->res.jsonValue["@odata.id"] = crow::utility::urlFromPieces(
        "redfish", "v1", "Chassis", chassisId, "ThermalSubsystem", "Fans");
    asyncResp->res.jsonValue["Name"] = "Fan Collection";
    asyncResp->res.jsonValue["Description"] =
        "The collasync_method_callection of Fan resource instances " +
        chassisId;
    managedStore::ManagedObjectStoreContext requestContext(asyncResp);
    managedStore::managedObjectStore->getSubTree(
        "/xyz/openbmc_project/inventory", 0, fanInterfaces, requestContext,
        [asyncResp, chassisId](
            const boost::system::error_code ec,
            const std::vector<std::pair<
                std::string,
                std::vector<std::pair<std::string, std::vector<std::string>>>>>&
                fansubtree) {
        if (ec)
        {
            BMCWEB_LOG_DEBUG << "DBUS response error";
            messages::internalError(asyncResp->res);
            return;
        }

        nlohmann::json& fanList = asyncResp->res.jsonValue["Members"];
        fanList = nlohmann::json::array();

        std::string newPath =
            "/redfish/v1/Chassis/" + chassisId + "/ThermalSubsystem/Fans/";

        for (const auto& [objectPath, serviceName] : fansubtree)
        {
            if (objectPath.empty() || serviceName.size() != 1)
            {
                BMCWEB_LOG_DEBUG << "Error getting D-Bus object!";
                messages::internalError(asyncResp->res);
                return;
            }
            const std::string& validPath = objectPath;
            // const std::string& connectionName = serviceName[0].first;
            std::string chassisName;
            std::string fanName;

            // 5 and 6 below comes from
            // /xyz/openbmc_project/inventory/system/chassis/chassisName/fanName
            //   0      1             2         3         4         5      6
            if (!dbus::utility::getNthStringFromPath(validPath, 5,
                                                     chassisName) ||
                !dbus::utility::getNthStringFromPath(validPath, 6, fanName))
            {
                BMCWEB_LOG_ERROR << "Got invalid path " << validPath;
                messages::invalidObject(asyncResp->res,
                                        crow::utility::urlFromPieces(
                                            "xyz", "openbmc_project",
                                            "inventory", "system", validPath));
                continue;
            }
            if (chassisName != chassisId)
            {
                BMCWEB_LOG_ERROR << "The fan obtained at this time "
                                    "does not belong to this chassis ";
                continue;
            }
            fanList.push_back({{"@odata.id", newPath + fanName + "/"}});
        }

        asyncResp->res.jsonValue["Members@odata.count"] = fanList.size();
    });
}

inline void requestRoutesFanCollection(App& app)
{
    BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ThermalSubsystem/Fans/")
        .privileges(redfish::privileges::getFanCollection)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& chassisId) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp))
        {
            return;
        }
        auto getChassisId = [asyncResp, chassisId](
                                const std::optional<std::string>& chassisPath) {
            if (!chassisPath)
            {
                BMCWEB_LOG_ERROR << "Not a valid chassis ID" << chassisId;
                messages::resourceNotFound(asyncResp->res, "Chassis",
                                           chassisId);
                return;
            }
            getValidFan(asyncResp, chassisId);
        };
        redfish::chassis_utils::getValidChassisPath(asyncResp, chassisId,
                                                    std::move(getChassisId));
        });
}

inline void requestRoutesFan(App& app)
{
    BMCWEB_ROUTE(app, "/redfish/v1/Chassis/<str>/ThermalSubsystem/Fans/<str>/")
        .privileges(redfish::privileges::getFan)
        .methods(boost::beast::http::verb::get)(
            [&app](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   const std::string& chassisId, const std::string& fanId) {
        if (!redfish::setUpRedfishRoute(app, req, asyncResp))
        {
            return;
        }
        auto getChassisId = [asyncResp, chassisId, fanId](
                                const std::optional<std::string>& chassisPath) {
            if (!chassisPath)
            {
                BMCWEB_LOG_ERROR << "Not a valid chassis ID" << chassisId;
                messages::resourceNotFound(asyncResp->res, "Chassis",
                                           chassisId);
                return;
            }
            auto respHandler =
                [asyncResp, chassisId, fanId](
                    const boost::system::error_code ec,
                    const dbus::utility::MapperGetSubTreeResponse& subtree) {
                if (ec)
                {
                    BMCWEB_LOG_DEBUG << "DBUS response error";
                    messages::internalError(asyncResp->res);
                    return;
                }
                for (const auto& [objectPath, serviceMap] : subtree)
                {
                    sdbusplus::message::object_path path(objectPath);
                    if (path.filename() != fanId)
                    {
                        continue;
                    }
                    std::string newPath = "/redfish/v1/Chassis/" + chassisId +
                                          "/ThermalSubsystem/Fans/";
                    asyncResp->res.jsonValue["@odata.type"] = "#Fan.v1_2_0.Fan";
                    asyncResp->res.jsonValue["Name"] = fanId;
                    asyncResp->res.jsonValue["Id"] = fanId;
                    asyncResp->res.jsonValue["@odata.id"] =
                        crow::utility::urlFromPieces(
                            "redfish", "v1", "Chassis", chassisId,
                            "ThermalSubsystem", "Fans", fanId);
                    getFanProperties(asyncResp, objectPath, serviceMap,
                                     chassisId);
                    return;
                }
            };
            managedStore::ManagedObjectStoreContext requestContext(asyncResp);
            managedStore::managedObjectStore->getSubTree(
                "/xyz/openbmc_project/inventory", 0, fanInterfaces,
                requestContext, respHandler);
        };
        redfish::chassis_utils::getValidChassisPath(asyncResp, chassisId,
                                                    std::move(getChassisId));
        });
}

} // namespace redfish