// SPDX-License-Identifier: Apache-2.0

// SPDX-FileCopyrightText: Copyright OpenBMC Authors

// SPDX-FileCopyrightText: Copyright 2019 Intel Corporation

#pragma once

#include "async_resp.hpp"

#include "dbus_singleton.hpp"

#include "dbus_utility.hpp"

#include "error_messages.hpp"

#include "generated/enums/chassis.hpp"

#include "logging.hpp"

#include "utils/dbus_utils.hpp"

#include <asm-generic/errno.h>

#include <boost/system/error_code.hpp>

#include <sdbusplus/asio/property.hpp>

#include <sdbusplus/message/native_types.hpp>

#include <array>

#include <functional>

#include <memory>

#include <string>

#include <string_view>

#include <utility>

namespace redfish

{

static constexpr std::array<std::string_view, 1> ledGroupInterface = {

    "xyz.openbmc_project.Led.Group"};

/**

 * @brief Retrieves identify led group properties over dbus

 *

 * @param[in] asyncResp     Shared pointer for generating response message.

 *

 * @return None.

 */

// TODO (Gunnar): Remove IndicatorLED after enough time has passed

inline void getIndicatorLedState(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)

{

    BMCWEB_LOG_DEBUG("Get led groups");

    dbus::utility::getProperty<bool>(

        "xyz.openbmc_project.LED.GroupManager",

        "/xyz/openbmc_project/led/groups/enclosure_identify_blink",

        "xyz.openbmc_project.Led.Group", "Asserted",

        // ast-grep-ignore: long-lambda

        [asyncResp](const boost::system::error_code& ec, const bool blinking) {

            // Some systems may not have enclosure_identify_blink object so

            // proceed to get enclosure_identify state.

            if (ec == boost::system::errc::invalid_argument)

            {

                BMCWEB_LOG_DEBUG(

                    "Get identity blinking LED failed, mismatch in property type");

                messages::internalError(asyncResp->res);

                return;

            }

            // Blinking ON, no need to check enclosure_identify assert.

            if (!ec && blinking)

            {

                asyncResp->res.jsonValue["IndicatorLED"] =

                    chassis::IndicatorLED::Blinking;

                return;

            }

            dbus::utility::getProperty<bool>(

                "xyz.openbmc_project.LED.GroupManager",

                "/xyz/openbmc_project/led/groups/enclosure_identify",

                "xyz.openbmc_project.Led.Group", "Asserted",

                // ast-grep-ignore: long-lambda

                [asyncResp](const boost::system::error_code& ec2,

                            const bool ledOn) {

                    if (ec2 == boost::system::errc::invalid_argument)

                    {

                        BMCWEB_LOG_DEBUG(

                            "Get enclosure identity led failed, mismatch in property type");

                        messages::internalError(asyncResp->res);

                        return;

                    }

                    if (ec2)

                    {

                        return;

                    }

                    if (ledOn)

                    {

                        asyncResp->res.jsonValue["IndicatorLED"] =

                            chassis::IndicatorLED::Lit;

                    }

                    else

                    {

                        asyncResp->res.jsonValue["IndicatorLED"] =

                            chassis::IndicatorLED::Off;

                    }

                });

        });

}

/**

 * @brief Sets identify led group properties

 *

 * @param[in] asyncResp     Shared pointer for generating response message.

 * @param[in] ledState  LED state passed from request

 *

 * @return None.

 */

// TODO (Gunnar): Remove IndicatorLED after enough time has passed

inline void setIndicatorLedState(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,

    const std::string& ledState)

{

    BMCWEB_LOG_DEBUG("Set led groups");

    bool ledOn = false;

    bool ledBlinkng = false;

    if (ledState == "Lit")

    {

        ledOn = true;

    }

    else if (ledState == "Blinking")

    {

        ledBlinkng = true;

    }

    else if (ledState != "Off")

    {

        messages::propertyValueNotInList(asyncResp->res, ledState,

                                         "IndicatorLED");

        return;

    }

    sdbusplus::asio::setProperty(

        *crow::connections::systemBus, "xyz.openbmc_project.LED.GroupManager",

        "/xyz/openbmc_project/led/groups/enclosure_identify_blink",

        "xyz.openbmc_project.Led.Group", "Asserted", ledBlinkng,

        // ast-grep-ignore: long-lambda

        [asyncResp, ledOn,

         ledBlinkng](const boost::system::error_code& ec) mutable {

            if (ec)

            {

                // Some systems may not have enclosure_identify_blink object so

                // Lets set enclosure_identify state to true if Blinking is

                // true.

                if (ledBlinkng)

                {

                    ledOn = true;

                }

            }

            setDbusProperty(

                asyncResp, "IndicatorLED",

                "xyz.openbmc_project.LED.GroupManager",

                sdbusplus::object_path(

                    "/xyz/openbmc_project/led/groups/enclosure_identify"),

                "xyz.openbmc_project.Led.Group", "Asserted", ledBlinkng);

        });

}

/**

 * @brief Retrieves identify system led group properties over dbus

 *

 * @param[in] asyncResp     Shared pointer for generating response message.

 *

 * @return None.

 */

inline void getSystemLocationIndicatorActive(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)

{

    BMCWEB_LOG_DEBUG("Get LocationIndicatorActive");

    dbus::utility::getProperty<bool>(

        "xyz.openbmc_project.LED.GroupManager",

        "/xyz/openbmc_project/led/groups/enclosure_identify_blink",

        "xyz.openbmc_project.Led.Group", "Asserted",

        // ast-grep-ignore: long-lambda

        [asyncResp](const boost::system::error_code& ec, const bool blinking) {

            // Some systems may not have enclosure_identify_blink object so

            // proceed to get enclosure_identify state.

            if (ec == boost::system::errc::invalid_argument)

            {

                BMCWEB_LOG_DEBUG(

                    "Get identity blinking LED failed, mismatch in property type");

                messages::internalError(asyncResp->res);

                return;

            }

            // Blinking ON, no need to check enclosure_identify assert.

            if (!ec && blinking)

            {

                asyncResp->res.jsonValue["LocationIndicatorActive"] = true;

                return;

            }

            dbus::utility::getProperty<bool>(

                "xyz.openbmc_project.LED.GroupManager",

                "/xyz/openbmc_project/led/groups/enclosure_identify",

                "xyz.openbmc_project.Led.Group", "Asserted",

                // ast-grep-ignore: long-lambda

                [asyncResp](const boost::system::error_code& ec2,

                            const bool ledOn) {

                    if (ec2 == boost::system::errc::invalid_argument)

                    {

                        BMCWEB_LOG_DEBUG(

                            "Get enclosure identity led failed, mismatch in property type");

                        messages::internalError(asyncResp->res);

                        return;

                    }

                    if (ec2)

                    {

                        return;

                    }

                    asyncResp->res.jsonValue["LocationIndicatorActive"] = ledOn;

                });

        });

}

/**

 * @brief Sets identify system led group properties

 *

 * @param[in] asyncResp     Shared pointer for generating response message.

 * @param[in] ledState  LED state passed from request

 *

 * @return None.

 */

inline void setSystemLocationIndicatorActive(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, const bool ledState)

{

    BMCWEB_LOG_DEBUG("Set LocationIndicatorActive");

    sdbusplus::asio::setProperty(

        *crow::connections::systemBus, "xyz.openbmc_project.LED.GroupManager",

        "/xyz/openbmc_project/led/groups/enclosure_identify_blink",

        "xyz.openbmc_project.Led.Group", "Asserted", ledState,

        // ast-grep-ignore: long-lambda

        [asyncResp, ledState](const boost::system::error_code& ec) {

            if (ec)

            {

                // Some systems may not have enclosure_identify_blink object so

                // lets set enclosure_identify state also if

                // enclosure_identify_blink failed

                setDbusProperty(

                    asyncResp, "LocationIndicatorActive",

                    "xyz.openbmc_project.LED.GroupManager",

                    sdbusplus::object_path(

                        "/xyz/openbmc_project/led/groups/enclosure_identify"),

                    "xyz.openbmc_project.Led.Group", "Asserted", ledState);

            }

        });

}

inline void handleLedGroupSubtree(

    const std::string& objPath, const boost::system::error_code& ec,

    const dbus::utility::MapperGetSubTreeResponse& subtree,

    const std::function<void(const boost::system::error_code& ec,

                             const std::string& ledGroupPath,

                             const std::string& service)>& callback)

{

    if (ec)

    {

        // Callback will handle the error

        callback(ec, "", "");

        return;

    }

    if (subtree.empty())

    {

        // Callback will handle the error

        BMCWEB_LOG_DEBUG(

            "No LED group associated with the specified object path: {}",

            objPath);

        callback(ec, "", "");

        return;

    }

    if (subtree.size() > 1)

    {

        // Callback will handle the error

        BMCWEB_LOG_DEBUG(

            "More than one LED group associated with the object {}: {}",

            objPath, subtree.size());

        callback(ec, "", "");

        return;

    }

    const auto& [ledGroupPath, serviceMap] = *subtree.begin();

    const auto& [service, interfaces] = *serviceMap.begin();

    callback(ec, ledGroupPath, service);

}

inline void getLedGroupPath(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,

    const std::string& objPath,

    std::function<void(const boost::system::error_code& ec,

                       const std::string& ledGroupPath,

                       const std::string& service)>&& callback)

{

    static constexpr const char* ledObjectPath =

        "/xyz/openbmc_project/led/groups";

    sdbusplus::object_path ledGroupAssociatedPath = objPath + "/identifying";

    dbus::utility::getAssociatedSubTree(

        ledGroupAssociatedPath, sdbusplus::object_path(ledObjectPath), 0,

        ledGroupInterface,

        [asyncResp, objPath, callback{std::move(callback)}](

            const boost::system::error_code& ec,

            const dbus::utility::MapperGetSubTreeResponse& subtree) {

            handleLedGroupSubtree(objPath, ec, subtree, callback);

        });

}

inline void afterGetLedState(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,

    const std::function<void(bool asserted)>& callback,

    const boost::system::error_code& ec, bool assert)

{

    if (ec)

    {

        if (ec.value() != EBADR)

        {

            BMCWEB_LOG_ERROR("DBUS response error for get ledState {}",

                             ec.value());

            messages::internalError(asyncResp->res);

        }

        return;

    }

    callback(assert);

}

inline void getLedState(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,

                        const std::function<void(bool asserted)>& callback,

                        const boost::system::error_code& ec,

                        const std::string& ledGroupPath,

                        const std::string& service)

{

    if (ec)

    {

        if (ec.value() != EBADR)

        {

            BMCWEB_LOG_ERROR("DBUS response error {}", ec.value());

            messages::internalError(asyncResp->res);

        }

        return;

    }

    if (ledGroupPath.empty() || service.empty())

    {

        // No LED group associated, not an error

        return;

    }

    sdbusplus::asio::getProperty<bool>(

        *crow::connections::systemBus, service, ledGroupPath,

        "xyz.openbmc_project.Led.Group", "Asserted",

        std::bind_front(afterGetLedState, asyncResp, callback));

}

/**

 * @brief Retrieves identify led group properties over dbus

 *

 * @param[in] asyncResp Shared pointer for generating response

 * message.

 * @param[in] objPath   Object path on PIM

 * @param[in] callback  to pass value

 * @return None.

 */

inline void getLocationIndicatorActive(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,

    const std::string& objPath, std::function<void(bool asserted)>&& callback)

{

    BMCWEB_LOG_DEBUG("Get LocationIndicatorActive for {}", objPath);

    getLedGroupPath(

        asyncResp, objPath,

        [asyncResp, callback = std::move(callback)](

            const boost::system::error_code& ec,

            const std::string& ledGroupPath, const std::string& service) {

            getLedState(asyncResp, callback, ec, ledGroupPath, service);

        });

}

inline void getLocationIndicatorActive(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,

    const std::string& objPath)

{

    getLocationIndicatorActive(asyncResp, objPath, [asyncResp](bool asserted) {

        asyncResp->res.jsonValue["LocationIndicatorActive"] = asserted;

    });

}

inline void setLedState(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,

                        bool ledState, const boost::system::error_code& ec,

                        const std::string& ledGroupPath,

                        const std::string& service)

{

    if (ec)

    {

        if (ec.value() == EBADR)

        {

            messages::propertyUnknown(asyncResp->res,

                                      "LocationIndicatorActive");

            return;

        }

        BMCWEB_LOG_ERROR("DBUS response error {}", ec.value());

        messages::internalError(asyncResp->res);

        return;

    }

    if (ledGroupPath.empty() || service.empty())

    {

        messages::propertyUnknown(asyncResp->res, "LocationIndicatorActive");

        return;

    }

    setDbusProperty(asyncResp, "LocationIndicatorActive", service, ledGroupPath,

                    "xyz.openbmc_project.Led.Group", "Asserted", ledState);

}

/**

 * @brief Sets identify led group properties

 *

 * @param[in] asyncResp     Shared pointer for generating response

 * message.

 * @param[in] objPath       Object path on PIM

 * @param[in] ledState      LED state passed from request

 *

 * @return None.

 */

inline void setLocationIndicatorActive(

    const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,

    const std::string& objPath, bool ledState)

{

    BMCWEB_LOG_DEBUG("Set LocationIndicatorActive for {}", objPath);

    getLedGroupPath(

        asyncResp, objPath,

        [asyncResp, ledState](const boost::system::error_code& ec,

                              const std::string& ledGroupPath,

                              const std::string& service) {

            setLedState(asyncResp, ledState, ec, ledGroupPath, service);

        });

}

} // namespace redfish