/*
 * Copyright (c) 2026 Huawei Technologies Co., Ltd.
 * openUBMC is licensed under Mulan PSL v2.
 * You can use this software according to the terms and conditions of the Mulan PSL v2.
 * You may obtain a copy of Mulan PSL v2 at:
 *         http://license.coscl.org.cn/MulanPSL2
 * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
 * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
 * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
 * See the Mulan PSL v2 for more details.
 */

#include <functional>
#include <mc/common.h>
#include <mctp/mctp.h>
#include <memory>
#include <ssu_oob/ssu_oob.h>
#include <string>
#include <test_utilities/test_base.h>
#include <vector>
#include <gtest/gtest.h>

#define private public
#include "ssu_card.h"
#undef private

namespace dev {
void set_mctp_request_handler(std::function<bool(const mc::dict&, const std::vector<uint8_t>&, std::string&)> handler);
} // namespace dev

using namespace dev;

namespace {

const std::string TEST_ELABEL = "SN001";

// 构造 SSU OOB 响应:NVMe-MI响应头(4字节) + CQE(12字节, status位于整体第14-15字节) + payload
std::string build_response(uint16_t status, const std::vector<uint8_t>& payload)
{
    std::vector<uint8_t> rsp;
    // NVMe-MI 响应头:protocol_status(1) + reserved(3)
    rsp.insert(rsp.end(), 4, 0);
    // SSU CQE:12字节,status 位于 CQE 内第10-11字节(整体第14-15字节)
    std::vector<uint8_t> cqe(12, 0);
    cqe[10] = static_cast<uint8_t>(status & 0xFF);
    cqe[11] = static_cast<uint8_t>((status >> 8) & 0xFF);
    rsp.insert(rsp.end(), cqe.begin(), cqe.end());
    rsp.insert(rsp.end(), payload.begin(), payload.end());
    return std::string(rsp.begin(), rsp.end());
}

class ssu_card_test_service : public mc::engine::service {
public:
    ssu_card_test_service(const std::string& name) : mc::engine::service(name)
    {}
};

class SsuChipTest : public mc::test::TestWithEngine {
protected:
    static void SetUpTestSuite()
    {
        TestWithEngine::SetUpTestSuite();
        m_service = mc::make_shared<ssu_card_test_service>("bmc.kepler.test_ssu_card");
        m_service->init();
        m_service->start();
    }

    static void TearDownTestSuite()
    {
        m_service->stop();
        m_service.reset();
        TestWithEngine::TearDownTestSuite();
    }

    void SetUp() override
    {
        dev::set_mctp_request_handler(nullptr);
        m_mctp = mc::make_shared<dev::mctp>(nullptr, 0, dev::MCTP_MESSAGE_TYPE_NVME, "");
    }

    void TearDown() override
    {
        dev::set_mctp_request_handler(nullptr);
        if (m_card) {
            m_service->unregister_object(std::string(m_card->get_object_path()));
            m_card.reset();
        }
        m_mctp.reset();
    }

    // 创建并注册 SsuCard 对象(m_chip 的 get_owner() 即返回该对象)
    void create_card()
    {
        m_card = mc::make_shared<dev::ssu_card>();
        m_card->set_object_name("SsuCard");
        m_card->set_object_path("/bmc/dev/Systems/1/SsuCards/SsuCard");
        m_service->register_object(m_card);
    }

    // 注入带外链路就绪的 ssu_oob(m_ssu_oob 为私有成员,通过 #define private public 访问)
    void set_ssu_oob()
    {
        // slot 仅用于日志标识,UT 中固定为 1
        m_card->m_ssu_oob = std::make_shared<dev::ssu_oob>(*m_mctp, 1);
    }

    static mc::shared_ptr<ssu_card_test_service> m_service;
    mc::shared_ptr<dev::mctp>                    m_mctp;
    mc::shared_ptr<dev::ssu_card>                m_card;
};

mc::shared_ptr<ssu_card_test_service> SsuChipTest::m_service;

TEST_F(SsuChipTest, block_io_read_success)
{
    // owner/ssu_oob 就绪,mock_mctp 注入电子标签响应,返回字节流应与电子标签一致
    const std::vector<uint8_t> payload(TEST_ELABEL.begin(), TEST_ELABEL.end());
    dev::set_mctp_request_handler([payload](const mc::dict&, const std::vector<uint8_t>&, std::string& rsp) {
        rsp = build_response(SSU_CMD_STATUS_SUCCESS, payload);
        return true;
    });
    create_card();
    set_ssu_oob();

    auto result = m_card->m_chip.BlockIORead(0, static_cast<uint32_t>(payload.size()));
    EXPECT_EQ(result, payload);
}

TEST_F(SsuChipTest, block_io_read_partial_with_padding)
{
    // 按 offset/length 截取,超出电子标签末尾的部分补 0
    const std::vector<uint8_t> payload(TEST_ELABEL.begin(), TEST_ELABEL.end());
    dev::set_mctp_request_handler([payload](const mc::dict&, const std::vector<uint8_t>&, std::string& rsp) {
        rsp = build_response(SSU_CMD_STATUS_SUCCESS, payload);
        return true;
    });
    create_card();
    set_ssu_oob();

    // "SN001" 从 offset=2 开始是 "001",length=10 时剩余部分补 0
    std::vector<uint8_t> expected = {'0', '0', '1'};
    expected.resize(10, 0);
    auto result = m_card->m_chip.BlockIORead(2, 10);
    EXPECT_EQ(result, expected);
}

TEST_F(SsuChipTest, block_io_read_offset_out_of_range)
{
    // offset 超过电子标签长度时全部补 0
    const std::vector<uint8_t> payload(TEST_ELABEL.begin(), TEST_ELABEL.end());
    dev::set_mctp_request_handler([payload](const mc::dict&, const std::vector<uint8_t>&, std::string& rsp) {
        rsp = build_response(SSU_CMD_STATUS_SUCCESS, payload);
        return true;
    });
    create_card();
    set_ssu_oob();

    auto result = m_card->m_chip.BlockIORead(10, 4);
    EXPECT_EQ(result, std::vector<uint8_t>(4, 0));
}

TEST_F(SsuChipTest, block_io_read_length_zero)
{
    // length 为 0 时返回空(即使 get_elabel 成功)
    const std::vector<uint8_t> payload(TEST_ELABEL.begin(), TEST_ELABEL.end());
    dev::set_mctp_request_handler([payload](const mc::dict&, const std::vector<uint8_t>&, std::string& rsp) {
        rsp = build_response(SSU_CMD_STATUS_SUCCESS, payload);
        return true;
    });
    create_card();
    set_ssu_oob();

    auto result = m_card->m_chip.BlockIORead(0, 0);
    EXPECT_TRUE(result.empty());
}

TEST_F(SsuChipTest, block_io_read_owner_null)
{
    // owner 非 ssu_card(无宿主对象),应记录elog并返回空
    dev::SSUChip chip;
    // 测试中未为 SSUChip 设置宿主对象,set_owner(nullptr) 置为确定的“无宿主”态,
    // 避免 get_owner() 读到未初始化 owner 指针导致 dynamic_cast 崩溃(libmcpp 隐患,用例侧规避)
    chip.set_owner(nullptr);
    auto result = chip.BlockIORead(0, 0);
    EXPECT_TRUE(result.empty());
}

TEST_F(SsuChipTest, block_io_read_oob_null)
{
    // MCTP endpoint 未就绪(ssu_oob 为空),BlockIORead 应抛出错误而非返回空数组
    create_card();

    EXPECT_THROW(m_card->m_chip.BlockIORead(0, 0), mc::runtime_exception);
}

TEST_F(SsuChipTest, block_io_read_fail)
{
    // get_elabel 返回 false(查询命令失败),应记录elog并返回空
    dev::set_mctp_request_handler([](const mc::dict&, const std::vector<uint8_t>&, std::string&) {
        return false;
    });
    create_card();
    set_ssu_oob();

    auto result = m_card->m_chip.BlockIORead(0, 0);
    EXPECT_TRUE(result.empty());
}

} // namespace