// 继承gen命名空间的基类（双参模板：自身类型 + gen基类）
class NVMe_Smart : public mc::engine::interface<NVMe_Smart, gen::NVMe_Smart> {
public:
    // 实现具体功能
    void update_smart_info();
    void start_mctp_update_task(...);
};

// 注册（在实现文件末尾）
MC_REFLECT(dev::NVMe_Smart, (gen::NVMe_Smart), ())

// 1. 创建MCTP对象
mctp* mctp_object = new mctp(this, phy_addr,
                             MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NVME_MI, "");

// 2. 创建NVMe-MI协议对象
auto nvme_mi_huawei = std::make_shared<nvme_mi_over_mctp_huawei>(*mctp_object);

// 3. 发送NVMe-MI请求
auto response = nvme_mi_huawei->get_smart_info();

// 4. 创建VPD对象
auto nvme_mi_vpd_obj = std::make_shared<nvme_mi_vpd>(this);
nvme_mi_vpd_obj->init();

// 5. 读取VPD数据
double temperature = nvme_mi_vpd_obj->get_temperature();

#ifndef XYZ_NVME_H
#define XYZ_NVME_H

#include <mc/engine.h>
#include <mc/timer.h>
#include <nvme/nvme_mi_vpd.h>
#include <nvme/nvme_mi_over_mctp_xyz.h>
#include <mctp/mctp.h>

#include "interface/pcie_device.h"
#include "interface/nvme.h"
#include "interface/nvme/management.h"
#include "interface/nvme/product_info.h"
#include "interface/nvme/smart.h"
#include "interface/cooling.h"

namespace dev {

using nvme_mi_vpd_ptr = std::shared_ptr<nvme_mi_vpd>;
using nvme_mi_over_mctp_ptr = std::shared_ptr<nvme_mi_over_mctp_xyz>;
using mctp_ptr = std::shared_ptr<mctp>;

class xyz_nvme : public mc::engine::object<xyz_nvme> {
public:
    // MC_OBJECT宏定义：类名、对象类型、路径模式、接口列表
    MC_OBJECT(
        xyz_nvme, "PCIeNVMe",
        "/bmc/dev/Systems/1/PCIeNVMe/${object_name}",
        (PCIeDevice)(NVMe)(NVMe_Management)(NVMe_ProductInfo)(NVMe_Status)
        (Cooling)(NVMe_BasicManagement)(NVMe_NVMeMI)(NVMe_Smart)
    )

    xyz_nvme();     // 构造函数
    ~xyz_nvme();    // 析构函数

    // 生命周期方法
    bool init(mc::mutable_dict& csr_object, const mc::dict& connector);
    bool start();
    bool stop();

    // 接口成员变量
    uint8_t              m_system_id;
    PCIeDevice           m_pcie_device;
    NVMe                 m_nvme;
    NVMe_Management      m_nvme_management;
    NVMe_ProductInfo     m_nvme_product_info;
    NVMe_Status          m_nvme_status;
    Cooling              m_cooling;
    NVMe_BasicManagement m_nvme_basic_management;
    NVMe_NVMeMI          m_nvme_nvme_mi;
    NVMe_Smart           m_nvme_smart;

private:
    bool init_nvme_mi_vpd_protocol();
    bool start_mctp_protocol();

    void start_vpd_update_tasks();
    void start_mctp_update_tasks();

    nvme_mi_vpd_ptr m_nvme_mi_vpd_obj;
    nvme_mi_over_mctp_ptr m_nvme_mi_over_mctp_obj;
    mctp* m_mctp_object;  // 管理MCTP对象生命周期

    // 更新间隔
    mc::milliseconds m_vpd_cooling_interval = mc::milliseconds(3000);
    mc::milliseconds m_vpd_status_interval = mc::milliseconds(10000);
    mc::milliseconds m_mctp_smart_interval = mc::milliseconds(120000);
};

} // namespace dev

#endif // XYZ_NVME_H

#include "xyz_nvme.h"
#include <mc/log.h>

namespace dev {

// 构造函数：初始化MCTP对象指针为nullptr
xyz_nvme::xyz_nvme() : m_mctp_object(nullptr) {
}

// 析构函数：释放MCTP对象，防止内存泄漏
xyz_nvme::~xyz_nvme() {
    if (m_mctp_object) {
        delete m_mctp_object;
        m_mctp_object = nullptr;
    }
}

// 初始化方法：从配置文件加载硬盘属性
bool xyz_nvme::init(mc::mutable_dict& csr_object, const mc::dict& connector) {
    try {
        // 使用from_variant自动加载配置到成员变量
        from_variant(csr_object, *this);
        ilog("xyz_nvme initialized successfully");
    } catch (const std::exception& e) {
        elog("xyz_nvme init failed, exception: ${exception}", ("exception", e.what()));
        return false;
    }
    return true;
}

// 启动方法：启动硬盘和所有协议
bool xyz_nvme::start() {
    // 初始化VPD协议
    if (!init_nvme_mi_vpd_protocol()) {
        elog("Failed to initialize VPD protocol");
        return false;
    }

    // 启动MCTP协议
    if (!start_mctp_protocol()) {
        elog("Failed to start MCTP protocol");
        return false;
    }

    // 启动VPD更新任务
    start_vpd_update_tasks();

    // 启动MCTP更新任务
    start_mctp_update_tasks();

    ilog("xyz_nvme started successfully");
    return true;
}

// 停止方法：停止硬盘并清理资源
bool xyz_nvme::stop() {
    // 停止所有接口的更新任务
    m_cooling.stop_vpd_update_task();
    m_nvme_status.stop_vpd_update_task();
    m_nvme_smart.stop_mctp_update_task();

    ilog("xyz_nvme stopped");
    return true;
}

// 初始化NVMe-MI VPD协议
bool xyz_nvme::init_nvme_mi_vpd_protocol() {
    m_nvme_mi_vpd_obj = std::make_shared<nvme_mi_vpd>(this);
    // 初始化VPD对象
    // ...
    return true;
}

// 启动MCTP协议：创建MCTP通信和NVMe-MI协议实例
bool xyz_nvme::start_mctp_protocol() {
    // 获取BDF地址
    // 创建MCTP对象（赋值给成员变量）
    m_mctp_object = new mctp(this, phy_addr,
                             MCTP_MESSAGE_TYPE::MCTP_MESSAGE_TYPE_NVME_MI, "");

    // 创建NVMe-MI协议实例
    m_nvme_mi_over_mctp_obj = std::make_shared<nvme_mi_over_mctp_xyz>(*m_mctp_object);

    // 创建传输层并启动
    // ...
    return true;
}

// 启动VPD更新任务
void xyz_nvme::start_vpd_update_tasks() {
    m_cooling.start_vpd_update_task(m_nvme_mi_vpd_obj, m_vpd_cooling_interval);
    m_nvme_status.start_vpd_update_task(m_nvme_mi_vpd_obj, m_vpd_status_interval);
}

// 启动MCTP更新任务
void xyz_nvme::start_mctp_update_tasks() {
    m_nvme_smart.start_mctp_update_task(m_nvme_mi_over_mctp_obj, m_mctp_smart_interval);
}

// MC_REFLECT宏：反射信息注册（放在实现文件末尾）
MC_REFLECT(dev::xyz_nvme,
           ((m_system_id, "SystemId"))
           ((m_pcie_device, "bmc.dev.PCIeDevice"))
           ((m_nvme, "bmc.dev.NVMe"))
           ((m_nvme_management, "bmc.dev.NVMe.Management"))
           ((m_nvme_product_info, "bmc.dev.NVMe.ProductInfo"))
           ((m_nvme_status, "bmc.dev.NVMe.Status"))
           ((m_cooling, "bmc.dev.Cooling"))
           ((m_nvme_basic_management, "bmc.dev.NVMe.BasicManagement"))
           ((m_nvme_nvme_mi, "bmc.dev.NVMe.NVMeMI"))
           ((m_nvme_smart, "bmc.dev.NVMe.Smart")))

} // namespace dev

// 继承自生成的基类（双参模板）
class NVMe_Smart : public mc::engine::interface<NVMe_Smart, gen::NVMe_Smart> {
public:
    // 启动MCTP更新任务：创建定时器周期性更新属性
    void start_mctp_update_task(nvme_mi_over_mctp_ptr nvme_mi,
                                mc::milliseconds interval,
                                std::function<void()> on_update_callback = nullptr);

    // 停止更新任务：停止并释放定时器
    void stop_mctp_update_task();

    // 更新方法：通过NVMe-MI协议获取数据并更新属性
    void update_smart_info();

private:
    mc::timer_ptr              m_mctp_timer;
    nvme_mi_over_mctp_ptr      m_nvme_mi;
};

// MC_REFLECT注册：指定基类（放在实现文件末尾）
MC_REFLECT(dev::NVMe_Smart, (gen::NVMe_Smart), ())

// 启动更新任务：创建定时器周期性更新属性
void NVMe_Smart::start_mctp_update_task(nvme_mi_over_mctp_ptr nvme_mi,
                                        mc::milliseconds interval) {
    m_nvme_mi = nvme_mi;
    m_mctp_timer = mc::make_shared<mc::timer>(this);

    m_mctp_timer->timeout.connect([this]() {
        update_smart_info();
    });

    m_mctp_timer->set_single_shot(false);
    m_mctp_timer->start(interval);

    // 立即执行一次更新
    update_smart_info();
}

// 停止更新任务：停止并释放定时器
void NVMe_Smart::stop_mctp_update_task() {
    if (m_mctp_timer) {
        m_mctp_timer->stop();
        m_mctp_timer.reset();
    }
}

// 更新SMART信息：通过NVMe-MI协议获取并更新SMART属性
void NVMe_Smart::update_smart_info() {
    try {
        // 调用协议获取SMART信息
        auto smart_data = m_nvme_mi->get_smart_info();

        // 解析响应数据
        // 更新属性：TemperatureCelsius = parsed_temperature
        TemperatureCelsius = smart_data.temperature;
        AvailableSparePercent = smart_data.available_spare;
        MediaErrors = smart_data.media_errors;

    } catch (const std::exception& e) {
        elog("Failed to update SMART info: ${error}", ("error", e.what()));
    }
}

#include <devmon/driver_abi.h>
#include <mc/log.h>

#include "xyz_nvme.h"

using namespace dev;

extern "C" {

// ============================================
// 硬盘主对象ABI函数
// ============================================

// 创建硬盘对象：分配内存并设置基本属性
driver_handle_t create_xyz_nvme(void* service, const char* name) {
    if (!service || !name) {
        elog("create_xyz_nvme: invalid parameters");
        return nullptr;
    }

    auto* nvme = new xyz_nvme();
    nvme->set_service(static_cast<mc::engine::service*>(service));
    nvme->set_object_name(name);

    ilog("Created xyz_nvme object: ${name}", ("name", name));
    return nvme;
}

// 初始化硬盘对象：加载配置
status_t init_xyz_nvme(driver_handle_t device, void* csr_object, void* connector) {
    if (!device || !csr_object || !connector) {
        elog("init_xyz_nvme: invalid parameters");
        return STATUS_INVALID_PARAM;
    }

    auto* nvme = static_cast<xyz_nvme*>(device);
    auto& csr = *static_cast<mc::mutable_dict*>(csr_object);
    auto& conn = *static_cast<mc::dict*>(connector);

    if (!nvme->init(csr, conn)) {
        elog("init_xyz_nvme failed");
        return STATUS_ERROR;
    }

    return STATUS_OK;
}

// 启动硬盘对象：启动设备和协议
status_t start_xyz_nvme(driver_handle_t device) {
    if (!device) {
        elog("start_xyz_nvme: invalid parameters");
        return STATUS_INVALID_PARAM;
    }

    auto* nvme = static_cast<xyz_nvme*>(device);
    if (!nvme->start()) {
        elog("start_xyz_nvme failed");
        return STATUS_ERROR;
    }

    return STATUS_OK;
}

// 停止硬盘对象：停止设备和清理资源
status_t stop_xyz_nvme(driver_handle_t device) {
    if (!device) {
        elog("stop_xyz_nvme: invalid parameters");
        return STATUS_INVALID_PARAM;
    }

    auto* nvme = static_cast<xyz_nvme*>(device);
    nvme->stop();

    return STATUS_OK;
}

// ============================================
// 驱动注册
// ============================================

// 硬盘主对象驱动结构体：定义设备名和生命周期函数
device_driver_t xyz_nvme_device_driver = {
    .device_name = "PCIeNVMe",           // 设备类型名（必须与DDS文件一致）
    .ctor        = create_xyz_nvme,      // 创建函数
    .init        = init_xyz_nvme,        // 初始化函数
    .start       = start_xyz_nvme,       // 启动函数
    .stop        = stop_xyz_nvme         // 停止函数
};

// 驱动数组：包含所有设备类型的驱动
device_driver_t xyz_nvme_driver_array[] = {
    xyz_nvme_device_driver
};

// 驱动注册函数：框架调用此函数获取驱动列表
status_t register_device_driver(device_driver_t** device_driver, uint8_t* count) {
    *device_driver = xyz_nvme_driver_array;
    *count = sizeof(xyz_nvme_driver_array) / sizeof(xyz_nvme_driver_array[0]);

    ilog("Registered xyz_nvme device driver: ${count} devices", ("count", *count));
    return STATUS_OK;
}

} // extern "C"

ilog("Starting xyz_nvme: ${name} at slot ${slot}",
     ("name", disk_name)("slot", slot_id));

try {
    bool ret = operation();
    if (!ret) {
        elog("Operation failed: ${reason}", ("reason", error_msg));
        return false;
    }
} catch (const std::exception& e) {
    elog("Exception caught: ${error}", ("error", e.what()));
    return false;
}

// 不同接口使用不同的更新间隔
m_cooling.start_vpd_update_task(vpd_obj, mc::milliseconds(3000));        // 温度：3秒
m_nvme_status.start_vpd_update_task(vpd_obj, mc::milliseconds(10000));   // 状态：10秒
m_nvme_smart.start_mctp_update_task(mctp_obj, mc::milliseconds(120000)); // SMART：120秒

// 头文件声明
class xyz_nvme : public mc::engine::object<xyz_nvme> {
private:
    mctp* m_mctp_object;  // 使用成员变量管理
};

// 实现文件
xyz_nvme::xyz_nvme() : m_mctp_object(nullptr) {}

xyz_nvme::~xyz_nvme() {
    // 在析构函数中释放，防止内存泄漏
    if (m_mctp_object) {
        delete m_mctp_object;
        m_mctp_object = nullptr;
    }
}

bool xyz_nvme::start_mctp_protocol() {
    // 赋值给成员变量，而不是局部变量
    m_mctp_object = new mctp(this, phy_addr, ...);
}

// 清理定时器（mc::timer_ptr 为共享指针）
if (m_timer) {
    m_timer->stop();
    m_timer.reset();
}

TEST(xyz_nvme, test_init) {
    xyz_nvme nvme;
    mc::mutable_dict csr_object = {...};
    mc::dict connector = {...};

    EXPECT_TRUE(nvme.init(csr_object, connector));
}