/*
 * 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 <internal/bus/bus_base/bus.h>
#include <internal/chip/chip_pca9545/pca9545.h>
#include <internal/hasdef.h>
#include <mc/dict.h>
#include <gtest/gtest.h>

#include <memory>
#include <string>
#include <vector>

namespace {

// ---------------------------------------------------------------------------
// Mock I2C bus for PCA9545 testing
// ---------------------------------------------------------------------------
class mock_i2c_bus : public dev::bus_base {
public:
    uint32_t read(ACCESS_DATA_S& input) override
    {
        ++m_read_count;
        return m_read_result;
    }

    uint32_t write(ACCESS_DATA_S& input) override
    {
        ++m_write_count;
        m_last_write_data = input.in_buffer;
        return m_write_result;
    }

    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;
    }
    void set_write_result(int32_t r)
    {
        m_write_result = r;
    }

    const std::vector<uint8_t>& last_write_data() const
    {
        return m_last_write_data;
    }

    int m_read_count  = 0;
    int m_write_count = 0;

private:
    uint8_t              m_id           = 0;
    int32_t              m_read_result  = HAS_OK;
    int32_t              m_write_result = HAS_OK;
    std::vector<uint8_t> m_last_write_data;
};

// ---------------------------------------------------------------------------
// Test fixture
// ---------------------------------------------------------------------------
class chip_pca9545_test : public ::testing::Test {
protected:
    void SetUp() override
    {
        m_bus = std::make_shared<mock_i2c_bus>();
        m_bus->set_id(0);
        m_chip = std::make_shared<dev::chip_pca9545>();
        m_chip->set_left_bus(m_bus);
        m_chip->set_host_bus(m_bus);
    }

    std::shared_ptr<mock_i2c_bus>      m_bus;
    std::shared_ptr<dev::chip_pca9545> m_chip;
};

// ===========================================================================
// init
// ===========================================================================

TEST_F(chip_pca9545_test, init_default)
{
    mc::mutable_dict csr;
    csr["object_name"] = "test_pca9545";
    EXPECT_TRUE(m_chip->init(csr));
}

TEST_F(chip_pca9545_test, init_with_channel_num)
{
    mc::mutable_dict csr;
    csr["object_name"] = "test_pca9545";
    csr["ChannelNum"]  = static_cast<uint8_t>(4);
    EXPECT_TRUE(m_chip->init(csr));
}

TEST_F(chip_pca9545_test, init_fails_on_invalid_csr)
{
    mc::mutable_dict csr;
    csr["object_name"] = "test_pca9545";
    csr["ChannelNum"]  = "not_a_number";
    EXPECT_FALSE(m_chip->init(csr));
}

// ===========================================================================
// chip_reset
// ===========================================================================

TEST_F(chip_pca9545_test, chip_reset_no_ref_returns_ok)
{
    // m_accessor_ref 为 nullptr 时直接返回 HAS_OK,不执行 I2C 操作
    int32_t ret = m_chip->chip_reset();
    EXPECT_EQ(ret, HAS_OK);
    EXPECT_TRUE(m_bus->last_write_data().empty());
}

TEST_F(chip_pca9545_test, chip_reset_no_ref_ignores_bus_error)
{
    // m_accessor_ref 为 nullptr 时不会触发 I2C 写入,bus 错误不影响返回值
    m_bus->set_write_result(HAS_ERR);
    int32_t ret = m_chip->chip_reset();
    EXPECT_EQ(ret, HAS_OK);
    EXPECT_TRUE(m_bus->last_write_data().empty());
}

// ===========================================================================
// open_channel
// ===========================================================================

TEST_F(chip_pca9545_test, open_channel_selects_correct_channel)
{
    // Set bus ID to 5 (channel 5)
    m_bus->set_id(5);

    int32_t ret = m_chip->open_channel(m_bus);
    EXPECT_EQ(ret, HAS_OK);
    ASSERT_FALSE(m_bus->last_write_data().empty());
    EXPECT_EQ(m_bus->last_write_data()[0], 1 << 5); // 0x20
}

TEST_F(chip_pca9545_test, open_channel_channel_0)
{
    m_bus->set_id(0);

    int32_t ret = m_chip->open_channel(m_bus);
    EXPECT_EQ(ret, HAS_OK);
    EXPECT_EQ(m_bus->last_write_data()[0], 1 << 0); // 0x01
}

TEST_F(chip_pca9545_test, open_channel_null_bus_throws)
{
    EXPECT_THROW(m_chip->open_channel(nullptr), mc::invalid_op_exception);
}

TEST_F(chip_pca9545_test, open_channel_invalid_id_throws)
{
    m_bus->set_id(8); // MAX_CHANNELS = 8, so id 8 is out of range
    EXPECT_THROW(m_chip->open_channel(m_bus), mc::invalid_op_exception);
}

TEST_F(chip_pca9545_test, open_channel_write_fails_throws)
{
    m_bus->set_write_result(HAS_ERR);
    EXPECT_THROW(m_chip->open_channel(m_bus), mc::invalid_op_exception);
}

// ===========================================================================
// close_channel
// ===========================================================================

TEST_F(chip_pca9545_test, close_channel_writes_zero)
{
    int32_t ret = m_chip->close_channel(m_bus);
    EXPECT_EQ(ret, HAS_OK);
    ASSERT_FALSE(m_bus->last_write_data().empty());
    EXPECT_EQ(m_bus->last_write_data()[0], 0x00);
}

TEST_F(chip_pca9545_test, close_channel_write_fails)
{
    m_bus->set_write_result(HAS_ERR);
    int32_t ret = m_chip->close_channel(m_bus);
    EXPECT_EQ(ret, HAS_ERR);
}

} // anonymous namespace