/*
 * 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 <gtest/gtest.h>

#include <algorithm>
#include <deque>
#include <internal/bus/bus_base/bus.h>
#include <internal/chip/chip_base/chip.h>
#include <internal/hasdef.h>
#include <mc/dict.h>
#include <mc/engine.h>
#include <smbus/std_smbus.h>
#include <stdexcept>
#include <string>

// 覆盖 do_mcu_switch 的请求内容与请求异常分支需要直接注入 m_smbus_obj、
// m_switch_capability_available,沿用仓库既有做法(test_connector.cpp)临时放开访问控制。
#define private public
#include <internal/chip/chip_mcu_switch/mcu_switch.h>
#undef private

namespace {

class test_bus : public dev::bus_base {
public:
    uint32_t read(ACCESS_DATA_S& input) override
    {
        (void)input;
        return HAS_OK;
    }

    uint32_t write(ACCESS_DATA_S& input) override
    {
        (void)input;
        return HAS_OK;
    }

    uint8_t get_id() override
    {
        return m_id;
    }

    void bus_lock() override
    {}
    void bus_unlock() override
    {}

    void set_id(uint8_t id)
    {
        m_id = id;
    }

private:
    uint8_t m_id = 0;
};

std::string build_capability_payload(const std::vector<uint16_t>& opcodes)
{
    std::string payload;
    payload.push_back('\x00');
    payload.push_back('\x00');
    payload.push_back('\x00');

    uint16_t count = static_cast<uint16_t>(opcodes.size());
    payload.push_back(static_cast<char>(count & 0xFF));
    payload.push_back(static_cast<char>((count >> 8) & 0xFF));

    for (uint16_t opcode : opcodes) {
        payload.push_back(static_cast<char>(opcode & 0xFF));
        payload.push_back(static_cast<char>((opcode >> 8) & 0xFF));
    }

    return payload;
}

class switch_test_chip : public dev::chip_mcu_switch {
public:
    struct queued_response {
        uint16_t    opcode;
        std::string data;
        uint16_t    error_code = 0;
    };

    void queue_response(uint16_t opcode, const std::string& data, uint16_t error_code = 0)
    {
        m_responses.push_back({opcode, data, error_code});
    }

    int32_t combo_block_write_read(uint32_t write_offset, const std::vector<uint8_t>& write_buffer,
                                   uint32_t read_offset, uint32_t read_length, std::vector<uint8_t>& in_buffer,
                                   std::vector<uint8_t>& out_buffer, std::string& error) override
    {
        (void)write_offset;
        (void)read_offset;
        (void)read_length;
        (void)in_buffer;

        if (m_responses.empty()) {
            throw std::runtime_error("no queued MCU switch response");
        }

        // write_buffer 可能为空(无数据写入时),先检查长度
        if (write_buffer.size() >= 5) {
            requested_opcodes.push_back(read_u16(write_buffer, 3));
            requested_payloads.push_back(extract_payload(write_buffer));
        }

        uint32_t request_offset = 0;
        uint32_t request_length = 0;
        if (write_buffer.size() >= 13) {
            request_offset = read_u32(write_buffer, 5);
            request_length = read_u32(write_buffer, 9);
        }

        const auto response = m_responses.front();
        if (request_offset >= response.data.size()) {
            out_buffer = build_protocol_response(response.opcode, response.data, response.error_code, "");
            m_responses.pop_front();
            return HAS_OK;
        }

        auto chunk_length = std::min<size_t>(request_length, response.data.size() - request_offset);
        auto chunk        = response.data.substr(request_offset, chunk_length);
        out_buffer        = build_protocol_response(response.opcode, response.data, response.error_code, chunk);

        if (request_offset + chunk_length >= response.data.size()) {
            m_responses.pop_front();
        }
        return HAS_OK;
    }

    std::vector<uint16_t>    requested_opcodes;
    std::vector<std::string> requested_payloads;

private:
    static uint16_t read_u16(const std::vector<uint8_t>& data, size_t offset)
    {
        return static_cast<uint16_t>(data.at(offset)) | (static_cast<uint16_t>(data.at(offset + 1)) << 8);
    }

    static uint32_t read_u32(const std::vector<uint8_t>& data, size_t offset)
    {
        return static_cast<uint32_t>(data.at(offset)) | (static_cast<uint32_t>(data.at(offset + 1)) << 8) |
               (static_cast<uint32_t>(data.at(offset + 2)) << 16) | (static_cast<uint32_t>(data.at(offset + 3)) << 24);
    }

    static std::string extract_payload(const std::vector<uint8_t>& request)
    {
        constexpr size_t request_header_len = 13;
        if (request.size() <= request_header_len + 1) {
            return "";
        }

        uint32_t declared_len  = read_u32(request, 9);
        size_t   available_len = request.size() - request_header_len - 1;
        size_t   payload_len   = std::min<size_t>(declared_len, available_len);
        return std::string(request.begin() + request_header_len, request.begin() + request_header_len + payload_len);
    }

    std::vector<uint8_t> build_protocol_response(uint16_t opcode, const std::string& full_data, uint16_t error_code,
                                                 const std::string& chunk_data) const
    {
        constexpr uint8_t read_command_code = 0x21;
        uint8_t           count             = static_cast<uint8_t>(header_len + chunk_data.size());
        uint32_t          total_length      = static_cast<uint32_t>(full_data.size());
        uint32_t          length            = static_cast<uint32_t>(chunk_data.size());

        std::string rsp_without_crc;
        rsp_without_crc.push_back(static_cast<char>(count));
        rsp_without_crc.append(reinterpret_cast<const char*>(&error_code), sizeof(error_code));
        rsp_without_crc.append(reinterpret_cast<const char*>(&opcode), sizeof(opcode));
        rsp_without_crc.append(reinterpret_cast<const char*>(&total_length), sizeof(total_length));
        rsp_without_crc.append(reinterpret_cast<const char*>(&length), sizeof(length));
        rsp_without_crc.append(chunk_data);

        std::string crc_input;
        crc_input.push_back(static_cast<char>(get_address()));
        crc_input.push_back(static_cast<char>(read_command_code));
        crc_input.push_back(static_cast<char>(get_address() | 0x01));
        crc_input.append(rsp_without_crc);

        uint8_t crc = mc::crypto::CRC8().calculate(crc_input);
        rsp_without_crc.push_back(static_cast<char>(crc));

        return std::vector<uint8_t>(rsp_without_crc.begin(), rsp_without_crc.end());
    }

    std::deque<queued_response> m_responses;
};

class chip_mcu_switch_test : public ::testing::Test {
protected:
    void SetUp() override
    {
        m_bus = std::make_shared<test_bus>();
        m_bus->set_id(1);
    }

    std::shared_ptr<test_bus> m_bus;
};

// 测试 open_channel 发送 capability 查询和 switch open 命令
TEST_F(chip_mcu_switch_test, open_channel_sends_capability_and_switch_open)
{
    auto switch_chip = std::make_shared<switch_test_chip>();

    mc::mutable_dict csr_object;
    csr_object["Address"]         = static_cast<uint32_t>(0xC8);
    csr_object["OffsetWidth"]     = static_cast<uint8_t>(1);
    csr_object["AddrWidth"]       = static_cast<uint8_t>(1);
    csr_object["WriteTmout"]      = static_cast<uint32_t>(100);
    csr_object["ReadTmout"]       = static_cast<uint32_t>(100);
    csr_object["SwitchSupported"] = true;
    csr_object["object_name"]     = std::string("chip-switch");

    // 入队:capability 响应(包含 switch opcode)+ switch open 响应
    switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload({MCU_SWITCH_OPCODE}));
    switch_chip->queue_response(MCU_SWITCH_OPCODE, "");

    ASSERT_TRUE(switch_chip->init(csr_object));
    EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);

    // open_channel 应发送 2 个请求:capability 查询 + switch open
    ASSERT_EQ(switch_chip->requested_opcodes.size(), 2U);
    EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
    EXPECT_EQ(switch_chip->requested_opcodes[1], MCU_SWITCH_OPCODE);
    ASSERT_EQ(switch_chip->requested_payloads.size(), 2U);
    EXPECT_TRUE(switch_chip->requested_payloads[0].empty());
    EXPECT_EQ(switch_chip->requested_payloads[1], std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
}

// 测试 close_channel 在 capability 检查通过后发送 switch close 命令
TEST_F(chip_mcu_switch_test, close_channel_sends_switch_close_after_capability_check)
{
    auto switch_chip = std::make_shared<switch_test_chip>();

    mc::mutable_dict csr_object;
    csr_object["Address"]         = static_cast<uint32_t>(0xC8);
    csr_object["OffsetWidth"]     = static_cast<uint8_t>(1);
    csr_object["AddrWidth"]       = static_cast<uint8_t>(1);
    csr_object["WriteTmout"]      = static_cast<uint32_t>(100);
    csr_object["ReadTmout"]       = static_cast<uint32_t>(100);
    csr_object["SwitchSupported"] = true;

    // 入队:capability 响应 + switch open 响应 + switch close 响应
    switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload({MCU_SWITCH_OPCODE}));
    switch_chip->queue_response(MCU_SWITCH_OPCODE, "");
    switch_chip->queue_response(MCU_SWITCH_OPCODE, "");

    ASSERT_TRUE(switch_chip->init(csr_object));
    EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
    EXPECT_EQ(switch_chip->close_channel(m_bus), HAS_OK);

    // open_channel: capability + switch open (2 requests)
    // close_channel: do_mcu_switch(CLOSE) 但 m_switch_capability_available 在 open_channel 中被设为 true
    //                所以 close_channel 的 do_mcu_switch 会发送 switch close 请求
    ASSERT_EQ(switch_chip->requested_opcodes.size(), 3U);
    EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
    EXPECT_EQ(switch_chip->requested_opcodes[1], MCU_SWITCH_OPCODE);
    EXPECT_EQ(switch_chip->requested_opcodes[2], MCU_SWITCH_OPCODE);
    ASSERT_EQ(switch_chip->requested_payloads.size(), 3U);
    EXPECT_TRUE(switch_chip->requested_payloads[0].empty());
    EXPECT_EQ(switch_chip->requested_payloads[1], std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
    EXPECT_EQ(switch_chip->requested_payloads[2], std::string(1, static_cast<char>(MCU_SWITCH_CLOSE_DATA)));
}

// 测试 capability 响应跨多帧时也能拼接后识别 switch opcode
TEST_F(chip_mcu_switch_test, capability_check_reads_multipage_response)
{
    auto switch_chip = std::make_shared<switch_test_chip>();

    mc::mutable_dict csr_object;
    csr_object["Address"]         = static_cast<uint32_t>(0xC8);
    csr_object["OffsetWidth"]     = static_cast<uint8_t>(1);
    csr_object["AddrWidth"]       = static_cast<uint8_t>(1);
    csr_object["WriteTmout"]      = static_cast<uint32_t>(100);
    csr_object["ReadTmout"]       = static_cast<uint32_t>(100);
    csr_object["SwitchSupported"] = true;

    std::vector<uint16_t> capability_opcodes = {0x0006, 0x0018, 0x0019, 0x001a, 0x0301,           0x0302,
                                                0x0303, 0x0304, 0x0305, 0x0306, MCU_SWITCH_OPCODE};

    switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload(capability_opcodes));
    switch_chip->queue_response(MCU_SWITCH_OPCODE, "");

    ASSERT_TRUE(switch_chip->init(csr_object));
    EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);

    ASSERT_EQ(switch_chip->requested_opcodes.size(), 3U);
    EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
    EXPECT_EQ(switch_chip->requested_opcodes[1], MCU_CAPABILITIES_OPCODE);
    EXPECT_EQ(switch_chip->requested_opcodes[2], MCU_SWITCH_OPCODE);
    EXPECT_EQ(switch_chip->requested_payloads[2], std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
}

// 测试 capability 查询失败时视为不支持 switch,open_channel 不反馈错误,后续访问可重试成功
TEST_F(chip_mcu_switch_test, capability_check_failure_is_treated_as_unsupported_and_can_retry)
{
    auto switch_chip = std::make_shared<switch_test_chip>();

    mc::mutable_dict csr_object;
    csr_object["Address"]         = static_cast<uint32_t>(0xC8);
    csr_object["OffsetWidth"]     = static_cast<uint8_t>(1);
    csr_object["AddrWidth"]       = static_cast<uint8_t>(1);
    csr_object["WriteTmout"]      = static_cast<uint32_t>(100);
    csr_object["ReadTmout"]       = static_cast<uint32_t>(100);
    csr_object["SwitchSupported"] = true;

    // 第一次 capability 响应太短(视为通信失败),第二次成功
    switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, std::string("\x00", 1));
    switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload({MCU_SWITCH_OPCODE}));
    switch_chip->queue_response(MCU_SWITCH_OPCODE, "");

    ASSERT_TRUE(switch_chip->init(csr_object));

    // 第一次 open_channel: capability 通信失败,视为不支持 switch,不发送 switch 且不反馈错误
    EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
    ASSERT_EQ(switch_chip->requested_opcodes.size(), 1U);
    EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);

    // 第二次 open_channel: capability 成功,switch open 发送
    EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);
    ASSERT_EQ(switch_chip->requested_opcodes.size(), 3U);
    EXPECT_EQ(switch_chip->requested_opcodes[1], MCU_CAPABILITIES_OPCODE);
    EXPECT_EQ(switch_chip->requested_opcodes[2], MCU_SWITCH_OPCODE);
    EXPECT_EQ(switch_chip->requested_payloads[2], std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
}

// 测试 SMBus 通信完全失败(无响应)时视为不支持 switch,open_channel 不反馈错误且不发送 switch
TEST_F(chip_mcu_switch_test, open_channel_treats_smbus_comm_failure_as_unsupported)
{
    auto switch_chip = std::make_shared<switch_test_chip>();

    mc::mutable_dict csr_object;
    csr_object["Address"]         = static_cast<uint32_t>(0xC8);
    csr_object["OffsetWidth"]     = static_cast<uint8_t>(1);
    csr_object["AddrWidth"]       = static_cast<uint8_t>(1);
    csr_object["WriteTmout"]      = static_cast<uint32_t>(100);
    csr_object["ReadTmout"]       = static_cast<uint32_t>(100);
    csr_object["SwitchSupported"] = true;

    // 不排队任何响应:底层 combo 直接失败,std_smbus 重试耗尽后返回空串
    ASSERT_TRUE(switch_chip->init(csr_object));
    EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);

    // 底层通信失败,未记录到任何请求(capability 请求已尝试但未被 mock 记录)
    EXPECT_TRUE(switch_chip->requested_opcodes.empty());
}

// 测试 MCU 不支持 switch opcode 时 open_channel 返回 HAS_OK 且不发送 switch 请求
TEST_F(chip_mcu_switch_test, unsupported_capability_does_not_send_switch_request)
{
    auto switch_chip = std::make_shared<switch_test_chip>();

    mc::mutable_dict csr_object;
    csr_object["Address"]         = static_cast<uint32_t>(0xC8);
    csr_object["OffsetWidth"]     = static_cast<uint8_t>(1);
    csr_object["AddrWidth"]       = static_cast<uint8_t>(1);
    csr_object["WriteTmout"]      = static_cast<uint32_t>(100);
    csr_object["ReadTmout"]       = static_cast<uint32_t>(100);
    csr_object["SwitchSupported"] = true;

    // capability 响应中不包含 switch opcode (0x0201)
    switch_chip->queue_response(MCU_CAPABILITIES_OPCODE, build_capability_payload({0x0300}));

    ASSERT_TRUE(switch_chip->init(csr_object));
    EXPECT_EQ(switch_chip->open_channel(m_bus), HAS_OK);

    // 只发送了 capability 请求,没有 switch 请求
    ASSERT_EQ(switch_chip->requested_opcodes.size(), 1U);
    EXPECT_EQ(switch_chip->requested_opcodes[0], MCU_CAPABILITIES_OPCODE);
    ASSERT_EQ(switch_chip->requested_payloads.size(), 1U);
    EXPECT_TRUE(switch_chip->requested_payloads[0].empty());
}

// ===========================================================================
// do_mcu_switch — 请求报文与请求异常
//
// 对应 mcu_switch.cpp 本次改动:抽出 switch_payload、新增 SetMcuSwitch 日志
// (走 dev::to_hex 输出 payload),并把请求异常分支的日志级别由 wlog 调整为 elog。
// ===========================================================================

class stub_smbus : public dev::std_smbus {
public:
    stub_smbus() : dev::std_smbus(nullptr)
    {}

    std::string send_request(mc::mutable_dict request) override
    {
        m_requests.push_back(request);
        if (m_throw) {
            throw std::runtime_error("injected smbus request failure");
        }
        return std::string();
    }

    void set_throw(bool value)
    {
        m_throw = value;
    }

    const std::vector<mc::mutable_dict>& requests() const
    {
        return m_requests;
    }

private:
    bool                          m_throw = false;
    std::vector<mc::mutable_dict> m_requests;
};

TEST_F(chip_mcu_switch_test, do_mcu_switch_is_noop_without_capability_or_smbus)
{
    auto chip = std::make_shared<dev::chip_mcu_switch>();

    // 既没有 capability 也没有 smbus 对象:直接返回 OK 且不发送请求
    EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_OPEN_DATA), HAS_OK);

    auto smbus        = std::make_shared<stub_smbus>();
    chip->m_smbus_obj = smbus;
    // capability 尚未就绪时依然不发送请求
    EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_OPEN_DATA), HAS_OK);
    EXPECT_TRUE(smbus->requests().empty());
}

TEST_F(chip_mcu_switch_test, do_mcu_switch_sends_single_byte_payload)
{
    auto chip                           = std::make_shared<dev::chip_mcu_switch>();
    auto smbus                          = std::make_shared<stub_smbus>();
    chip->m_smbus_obj                   = smbus;
    chip->m_switch_capability_available = true;

    EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_OPEN_DATA), HAS_OK);

    ASSERT_EQ(smbus->requests().size(), 1U);
    const mc::mutable_dict& request = smbus->requests()[0];
    ASSERT_TRUE(request.contains("opcode"));
    ASSERT_TRUE(request.contains("data"));
    ASSERT_TRUE(request.contains("expect_data_len"));
    EXPECT_EQ(request["opcode"].as<uint16_t>(), MCU_SWITCH_OPCODE);
    EXPECT_EQ(request["data"].as<std::string>(), std::string(1, static_cast<char>(MCU_SWITCH_OPEN_DATA)));
    EXPECT_EQ(request["expect_data_len"].as<int32_t>(), 0);
}

// close 的 payload 为 0x00 —— 同时覆盖 to_hex 对含 0x00 单字节输出的形态
TEST_F(chip_mcu_switch_test, do_mcu_switch_close_sends_zero_payload)
{
    auto chip                           = std::make_shared<dev::chip_mcu_switch>();
    auto smbus                          = std::make_shared<stub_smbus>();
    chip->m_smbus_obj                   = smbus;
    chip->m_switch_capability_available = true;

    EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_CLOSE_DATA), HAS_OK);

    ASSERT_EQ(smbus->requests().size(), 1U);
    EXPECT_EQ(smbus->requests()[0]["data"].as<std::string>(), std::string(1, '\0'));
}

TEST_F(chip_mcu_switch_test, do_mcu_switch_reports_request_exception)
{
    auto chip  = std::make_shared<dev::chip_mcu_switch>();
    auto smbus = std::make_shared<stub_smbus>();
    smbus->set_throw(true);
    chip->m_smbus_obj                   = smbus;
    chip->m_switch_capability_available = true;

    // open / close 两种 action 文案分支:底层发送异常时返回 HAS_ERR,不向外抛出
    EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_OPEN_DATA), HAS_ERR);
    EXPECT_EQ(chip->do_mcu_switch(MCU_SWITCH_CLOSE_DATA), HAS_ERR);
    EXPECT_EQ(smbus->requests().size(), 2U);
}

} // namespace