#pragma once

#include "MctpRequester.hpp"
#include "NvidiaGpuMctpVdm.hpp"

#include <boost/asio/io_context.hpp>
#include <boost/asio/steady_timer.hpp>
#include <sdbusplus/asio/connection.hpp>
#include <sdbusplus/asio/object_server.hpp>

#include <array>
#include <chrono>
#include <cstdint>
#include <memory>
#include <optional>
#include <string>
#include <unordered_map>

class Inventory : public std::enable_shared_from_this<Inventory>
{
  public:
    Inventory(
        const std::shared_ptr<sdbusplus::asio::connection>& conn,
        sdbusplus::asio::object_server& objectServer,
        const std::string& inventoryName, mctp::MctpRequester& mctpRequester,
        gpu::DeviceIdentification deviceType, uint8_t eid,
        boost::asio::io_context& io,
        const std::shared_ptr<sdbusplus::asio::dbus_interface>&
            powerCapInterface,
        const std::shared_ptr<sdbusplus::asio::dbus_interface>& dramItemIface);

    void init();

    std::optional<uint32_t> getMinPowerCap() const
    {
        return minPowerCapWatts;
    }

    std::optional<uint32_t> getMaxPowerCap() const
    {
        return maxPowerCapWatts;
    }

    std::optional<uint32_t> getMaxMemoryMiB() const
    {
        return memorySizeInMiB;
    }

    std::optional<uint64_t> getMinSpeedInHz() const
    {
        return minGraphicsClockHz;
    }

    std::optional<uint64_t> getMaxSpeedInHz() const
    {
        return maxGraphicsClockHz;
    }

  private:
    struct PropertyInfo
    {
        std::shared_ptr<sdbusplus::asio::dbus_interface> interface;
        std::string propertyName;
        int retryCount{0};
        bool isPending{false};
    };
    void sendInventoryPropertyRequest(gpu::InventoryPropertyId propertyId);
    void handleInventoryPropertyResponse(gpu::InventoryPropertyId propertyId,
                                         const std::error_code& ec,
                                         std::span<const uint8_t> buffer);
    void processNextProperty();
    void processInventoryProperty(gpu::InventoryPropertyId propertyId);
    void registerProperty(
        gpu::InventoryPropertyId propertyId,
        const std::shared_ptr<sdbusplus::asio::dbus_interface>& interface,
        const std::string& propertyName);
    std::optional<gpu::InventoryPropertyId> getNextPendingProperty() const;
    static void markPropertyPending(
        std::unordered_map<gpu::InventoryPropertyId, PropertyInfo>::iterator
            it);
    static void markPropertyProcessed(
        std::unordered_map<gpu::InventoryPropertyId, PropertyInfo>::iterator
            it);

    std::shared_ptr<sdbusplus::asio::dbus_interface> assetIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> acceleratorInterface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> uuidInterface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> revisionIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> dramItemInterface;
    std::array<uint16_t, 2> allowedSpeedsMT{0, 0};

    std::string name;
    mctp::MctpRequester& mctpRequester;
    gpu::DeviceIdentification deviceType;
    uint8_t eid;
    boost::asio::steady_timer retryTimer;
    std::unordered_map<gpu::InventoryPropertyId, PropertyInfo> properties;
    std::optional<uint32_t> memorySizeInMiB;
    std::array<uint8_t, gpu::getInventoryInformationRequestSize>
        requestBuffer{};
    std::optional<uint32_t> minPowerCapWatts;
    std::optional<uint32_t> maxPowerCapWatts;
    std::optional<uint64_t> minGraphicsClockHz;
    std::optional<uint64_t> maxGraphicsClockHz;

    static constexpr std::chrono::seconds retryDelay{5};
    static constexpr int maxRetryAttempts = 3;
};