/*
 * SPDX-FileCopyrightText: Copyright OpenBMC Authors
 * SPDX-License-Identifier: Apache-2.0
 */

#include "NvidiaEthPort.hpp"

#include "NvidiaUtils.hpp"
#include "Utils.hpp"

#include <bits/basic_string.h>

#include <MctpRequester.hpp>
#include <NvidiaGpuMctpVdm.hpp>
#include <OcpMctpVdm.hpp>
#include <phosphor-logging/lg2.hpp>
#include <sdbusplus/asio/connection.hpp>
#include <sdbusplus/asio/object_server.hpp>
#include <sdbusplus/message/native_types.hpp>

#include <array>
#include <cstdint>
#include <cstring>
#include <format>
#include <functional>
#include <memory>
#include <span>
#include <string>
#include <system_error>
#include <tuple>
#include <utility>
#include <vector>

using std::string;

using namespace std::literals;

static constexpr uint8_t permanentMacAddressTag = 2;

NvidiaEthPortMetrics::NvidiaEthPortMetrics(
    std::shared_ptr<sdbusplus::asio::connection>& conn,
    mctp::MctpRequester& mctpRequester, const std::string& name,
    const std::string& deviceName, const std::string& path, uint8_t eid,
    uint16_t portNumber, sdbusplus::asio::object_server& objectServer,
    const std::vector<std::pair<uint8_t, uint64_t>>& addresses) :
    eid(eid), portNumber(portNumber), path(path), conn(conn),
    mctpRequester(mctpRequester), objectServer(objectServer)
{
    const int rc = gpu::encodeGetEthernetPortTelemetryCountersRequest(
        0, portNumber, request);
    if (rc == 0)
    {
        requestEncoded = true;
    }
    else
    {
        lg2::error(
            "Failed to encode Ethernet Port Metrics request for EID={EID}, PortNumber={PN}, rc={RC}",
            "EID", eid, "PN", portNumber, "RC", rc);
    }

    const sdbusplus::object_path deviceDbusPath = inventoryPrefix / deviceName;

    const sdbusplus::object_path portDbusPath =
        inventoryPrefix / deviceName / name;

    const std::string metricsDbusPathPrefix =
        metricPath + std::format("port_{}_{}", deviceName, name);

    portInterface = objectServer.add_interface(
        portDbusPath, "xyz.openbmc_project.Inventory.Connector.Port");

    std::vector<Association> associations;
    associations.emplace_back("connected_to", "connecting", deviceDbusPath);

    associationInterface =
        objectServer.add_interface(portDbusPath, association::interface);

    associationInterface->register_property("Associations", associations);

    portInterface->register_property(
        "PortProtocol",
        std::string("xyz.openbmc_project.Inventory.Connector.Port."
                    "PortProtocol.Ethernet"));

    for (const auto& [tag, value] : addresses)
    {
        if (tag != permanentMacAddressTag)
        {
            continue;
        }

        std::array<uint8_t, 6> mac{};
        std::memcpy(mac.data(), &value, sizeof(mac));
        const std::string macStr =
            std::format("{:02X}:{:02X}:{:02X}:{:02X}:{:02X}:{:02X}", mac[0],
                        mac[1], mac[2], mac[3], mac[4], mac[5]);

        const sdbusplus::object_path ndfDbusPath =
            inventoryPrefix / deviceName / "NetworkDeviceFunctions" / name;

        networkDeviceFunctionInterface = objectServer.add_interface(
            ndfDbusPath, "xyz.openbmc_project.Inventory.Item.NetworkInterface");
        networkDeviceFunctionInterface->register_property("MACAddress", macStr);
        if (!networkDeviceFunctionInterface->initialize())
        {
            lg2::error(
                "Error initializing NetworkDeviceFunction interface, eid={EID}, portNumber={PN}",
                "EID", eid, "PN", portNumber);
        }

        std::vector<Association> ndfAssociations;
        ndfAssociations.emplace_back("exposed_by", "exposing", deviceDbusPath);
        ndfAssociations.emplace_back("assigned_to", "assigning", portDbusPath);
        networkDeviceFunctionAssociationInterface =
            objectServer.add_interface(ndfDbusPath, association::interface);
        networkDeviceFunctionAssociationInterface->register_property(
            "Associations", ndfAssociations);
        if (!networkDeviceFunctionAssociationInterface->initialize())
        {
            lg2::error(
                "Error initializing NetworkDeviceFunction Association interface, eid={EID}, portNumber={PN}",
                "EID", eid, "PN", portNumber);
        }
        break;
    }

    static constexpr auto telemetryMetrics =
        std::to_array<std::tuple<uint8_t, const char*, const std::string*>>({
            {0, "/nic/rx_bytes", &metricUnitBytes},
            {1, "/nic/tx_bytes", &metricUnitBytes},
            {2, "/nic/rx_unicast_frames", &metricUnitCount},
            {3, "/nic/rx_multicast_frames", &metricUnitCount},
            {4, "/nic/rx_broadcast_frames", &metricUnitCount},
            {5, "/nic/tx_unicast_frames", &metricUnitCount},
            {6, "/nic/tx_multicast_frames", &metricUnitCount},
            {7, "/nic/tx_broadcast_frames", &metricUnitCount},
            {8, "/nic/rx_fcs_errors", &metricUnitCount},
            {9, "/nic/rx_frame_alignment_errors", &metricUnitCount},
            {10, "/nic/rx_false_carrier_errors", &metricUnitCount},
            {11, "/nic/rx_undersize_frames", &metricUnitCount},
            {12, "/nic/rx_oversize_frames", &metricUnitCount},
            {13, "/nic/rx_pause_xon_frames", &metricUnitCount},
            {14, "/nic/rx_pause_xoff_frames", &metricUnitCount},
            {15, "/nic/tx_pause_xon_frames", &metricUnitCount},
            {16, "/nic/tx_pause_xoff_frames", &metricUnitCount},
            {17, "/nic/tx_single_collisions", &metricUnitCount},
            {18, "/nic/tx_multiple_collisions", &metricUnitCount},
            {19, "/nic/tx_late_collisions", &metricUnitCount},
            {20, "/nic/tx_excessive_collisions", &metricUnitCount},
        });

    for (const auto& [tag, metricName, unit] : telemetryMetrics)
    {
        metricValueInterface[tag] =
            objectServer.add_interface(metricsDbusPathPrefix + metricName,
                                       "xyz.openbmc_project.Metric.Value");

        metricValueInterface[tag]->register_property("Unit", *unit);
        metricValueInterface[tag]->register_property("Value", 0.0);

        std::vector<Association> associations;
        associations.emplace_back("measuring", "measured_by", portDbusPath);

        metricAssociationInterfaces[tag] = objectServer.add_interface(
            metricsDbusPathPrefix + metricName, association::interface);
        metricAssociationInterfaces[tag]->register_property("Associations",
                                                            associations);
        if (!metricValueInterface[tag]->initialize())
        {
            lg2::error(
                "Error initializing Ethernet Port Metric interface, eid={EID}, portNumber={PN}, metric={MN}",
                "EID", eid, "PN", portNumber, "MN", metricName);
        }

        if (!metricAssociationInterfaces[tag]->initialize())
        {
            lg2::error(
                "Error initializing Ethernet Port Metric Association interface, eid={EID}, portNumber={PN}, metric={MN}",
                "EID", eid, "PN", portNumber, "MN", metricName);
        }
    }

    if (!portInterface->initialize())
    {
        lg2::error(
            "Error initializing Ethernet Port interface, eid={EID}, portNumber={PN}",
            "EID", eid, "PN", portNumber);
    }

    if (!associationInterface->initialize())
    {
        lg2::error(
            "Error initializing Association interface for Ethernet Port, eid={EID}, portNumber={PN}",
            "EID", eid, "PN", portNumber);
    }
}

NvidiaEthPortMetrics::~NvidiaEthPortMetrics()
{
    objectServer.remove_interface(portInterface);
    objectServer.remove_interface(associationInterface);
    objectServer.remove_interface(networkDeviceFunctionInterface);
    objectServer.remove_interface(networkDeviceFunctionAssociationInterface);
    for (const auto& iface : metricValueInterface)
    {
        objectServer.remove_interface(iface);
    }
    for (const auto& iface : metricAssociationInterfaces)
    {
        objectServer.remove_interface(iface);
    }
}

void NvidiaEthPortMetrics::processResponse(
    const std::error_code& sendRecvMsgResult, std::span<const uint8_t> response)
{
    if (sendRecvMsgResult)
    {
        lg2::error(
            "Error updating Ethernet Port Metrics: sending message over MCTP failed, "
            "rc={RC}, EID={EID}, PortNumber={PN}",
            "RC", sendRecvMsgResult.message(), "EID", eid, "PN", portNumber);
        return;
    }

    ocp::accelerator_management::CompletionCode cc{};
    uint16_t reasonCode = 0;
    std::vector<std::pair<uint8_t, uint64_t>> telemetryValues;

    const int rc = gpu::decodeGetEthernetPortTelemetryCountersResponse(
        response, cc, reasonCode, telemetryValues);

    if (rc != 0 || cc != ocp::accelerator_management::CompletionCode::SUCCESS)
    {
        lg2::error(
            "Error updating Ethernet Port Metrics: decode failed, "
            "rc={RC}, cc={CC}, reasonCode={RESC}, EID={EID}, PortNumber={PN}",
            "RC", rc, "CC", static_cast<uint8_t>(cc), "RESC", reasonCode, "EID",
            eid, "PN", portNumber);
        return;
    }

    for (const auto& [tag, value] : telemetryValues)
    {
        if (tag < maxTelemetryValues && metricValueInterface[tag])
        {
            metricValueInterface[tag]->set_property("Value",
                                                    static_cast<double>(value));
        }
    }
}

void NvidiaEthPortMetrics::update()
{
    if (!requestEncoded)
    {
        return;
    }

    mctpRequester.sendRecvMsg(
        eid, request,
        [weak{weak_from_this()}](const std::error_code& ec,
                                 std::span<const uint8_t> buffer) {
            std::shared_ptr<NvidiaEthPortMetrics> self = weak.lock();
            if (!self)
            {
                lg2::error("Invalid reference to NvidiaEthPortMetrics");
                return;
            }
            self->processResponse(ec, buffer);
        });
}