/*
 * 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 <internal/bus/bus_base/bus.h>
#include <internal/chip/chip_ads78/ads78.h>
#include <mc/dict.h>
#include <mc/exception.h>

#include <cstring>
#include <deque>
#include <memory>
#include <stdexcept>
#include <string>
#include <vector>

namespace {

class ads78_test_bus : public dev::bus_base {
public:
    ads78_test_bus()           = default;
    ~ads78_test_bus() override = default;

    uint32_t read(ACCESS_DATA_S& input) override
    {
        ++m_read_call_count;
        if (m_throw_on_read) {
            throw std::runtime_error(m_exception_message);
        }
        m_last_access = input;
        if (!m_read_payloads.empty()) {
            input.out_buffer = m_read_payloads.front();
            m_read_payloads.pop_front();
        } else {
            input.out_buffer.clear();
        }
        return m_read_result;
    }

    uint32_t write(ACCESS_DATA_S& input) override
    {
        ++m_write_call_count;
        m_last_access = input;
        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 enqueue_read_payload(std::vector<uint8_t> payload)
    {
        m_read_payloads.emplace_back(std::move(payload));
    }

    void set_read_result(int32_t result)
    {
        m_read_result = result;
    }

    void set_write_result(int32_t result)
    {
        m_write_result = result;
    }

    void set_throw_on_read(bool enabled, std::string message = "mock read exception")
    {
        m_throw_on_read     = enabled;
        m_exception_message = std::move(message);
    }

    int read_call_count() const
    {
        return m_read_call_count;
    }

    int write_call_count() const
    {
        return m_write_call_count;
    }

    const ACCESS_DATA_S& last_access() const
    {
        return m_last_access;
    }

private:
    uint8_t                          m_id = 0;
    std::deque<std::vector<uint8_t>> m_read_payloads;
    int32_t                          m_read_result       = HAS_OK;
    int32_t                          m_write_result      = HAS_OK;
    bool                             m_throw_on_read     = false;
    std::string                      m_exception_message = "mock read exception";
    int                              m_read_call_count   = 0;
    int                              m_write_call_count  = 0;
    ACCESS_DATA_S                    m_last_access       = {};
};

class chip_ads78_test : public ::testing::Test {
protected:
    void SetUp() override
    {
        mc::mutable_dict csr;
        csr["Address"]     = static_cast<uint32_t>(0x50);
        csr["OffsetWidth"] = static_cast<uint8_t>(1);
        csr["AddrWidth"]   = static_cast<uint8_t>(1);
        csr["object_name"] = std::string("ads78_test");
        ASSERT_TRUE(m_chip.init(csr));
    }

    std::shared_ptr<ads78_test_bus> bind_test_bus()
    {
        auto bus = std::make_shared<ads78_test_bus>();
        m_chip.set_left_bus(bus);
        m_chip.set_host_bus(bus);
        return bus;
    }

    dev::chip_ads78 m_chip;
};

// ===== Init Tests =====

TEST_F(chip_ads78_test, init_success_with_minimal_config)
{
    dev::chip_ads78  chip;
    mc::mutable_dict csr;
    csr["Address"] = static_cast<uint32_t>(0x48);

    EXPECT_TRUE(chip.init(csr));
}

TEST_F(chip_ads78_test, init_success_with_full_config)
{
    dev::chip_ads78  chip;
    mc::mutable_dict csr;
    csr["Address"]     = static_cast<uint32_t>(0x50);
    csr["OffsetWidth"] = static_cast<uint8_t>(1);
    csr["AddrWidth"]   = static_cast<uint8_t>(1);
    csr["WriteTmout"]  = static_cast<uint32_t>(100);
    csr["ReadTmout"]   = static_cast<uint32_t>(100);
    csr["object_name"] = std::string("ads78_full_test");

    EXPECT_TRUE(chip.init(csr));
}

// NOTE: init_fails_with_invalid_address_type test removed - ads78::init doesn't
// check chip_base::init return value, so it always returns true even on failure.

// ===== Channel Tests (0-7) =====

TEST_F(chip_ads78_test, bit_read_channel_0_success)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(bus->last_access().offset, 0x84U);
}

TEST_F(chip_ads78_test, bit_read_channel_1_success)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(1, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(bus->last_access().offset, 0xC4U);
}

TEST_F(chip_ads78_test, bit_read_channel_2_success)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(2, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(bus->last_access().offset, 0x94U);
}

TEST_F(chip_ads78_test, bit_read_channel_3_success)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(3, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(bus->last_access().offset, 0xD4U);
}

TEST_F(chip_ads78_test, bit_read_channel_4_success)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(4, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(bus->last_access().offset, 0xA4U);
}

TEST_F(chip_ads78_test, bit_read_channel_5_success)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(5, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(bus->last_access().offset, 0xE4U);
}

TEST_F(chip_ads78_test, bit_read_channel_6_success)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(6, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(bus->last_access().offset, 0xB4U);
}

TEST_F(chip_ads78_test, bit_read_channel_7_success)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(7, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(bus->last_access().offset, 0xF4U);
}

// ===== ADC Conversion Tests =====

TEST_F(chip_ads78_test, bit_read_converts_zero_adc_value)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x00, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    EXPECT_EQ(out_buffer[0], 0);
    EXPECT_EQ(out_buffer[1], 0);
}

TEST_F(chip_ads78_test, bit_read_converts_max_adc_value)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    // Max 12-bit value: 0xFFF = 4095
    bus->enqueue_read_payload({0x0F, 0xFF});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    // Expected: (4095 * 2500) / 4096 = 2499
    EXPECT_EQ(out_buffer[0], 0xC3); // 2499 & 0xFF = 0xC3
    EXPECT_EQ(out_buffer[1], 0x09); // (2499 >> 8) & 0xFF = 0x09
}

TEST_F(chip_ads78_test, bit_read_converts_mid_scale_adc_value)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    // Mid-scale: 2048
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    // Expected: (2048 * 2500) / 4096 = 1250
    EXPECT_EQ(out_buffer[0], 0xE2); // 1250 & 0xFF = 0xE2
    EXPECT_EQ(out_buffer[1], 0x04); // (1250 >> 8) & 0xFF = 0x04
}

// ===== Error Path Tests =====

TEST_F(chip_ads78_test, bit_read_throws_when_bus_is_missing)
{
    dev::chip_ads78  chip_without_bus;
    mc::mutable_dict csr;
    csr["Address"] = static_cast<uint32_t>(0x48);
    ASSERT_TRUE(chip_without_bus.init(csr));

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_THROW(chip_without_bus.bit_read(0, 2, 0, in_buffer, out_buffer, error), mc::invalid_op_exception);
}

TEST_F(chip_ads78_test, bit_read_returns_error_for_invalid_channel_8)
{
    auto                 bus = bind_test_bus();
    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(8, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
    EXPECT_NE(error.find("invalid channel"), std::string::npos);
    EXPECT_EQ(bus->read_call_count(), 0);
}

TEST_F(chip_ads78_test, bit_read_returns_error_for_invalid_channel_100)
{
    auto                 bus = bind_test_bus();
    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(100, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
    EXPECT_FALSE(error.empty());
    EXPECT_EQ(bus->read_call_count(), 0);
}

TEST_F(chip_ads78_test, bit_read_returns_error_when_bus_read_fails)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_ERR);
    bus->enqueue_read_payload({0x00, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(1, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
    EXPECT_NE(error.find("read operation failed"), std::string::npos);
    EXPECT_EQ(bus->read_call_count(), 1);
}

TEST_F(chip_ads78_test, bit_read_returns_error_when_data_is_insufficient)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(2, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
    EXPECT_NE(error.find("insufficient data"), std::string::npos);
}

TEST_F(chip_ads78_test, bit_read_handles_bus_exception)
{
    auto bus = bind_test_bus();
    bus->set_throw_on_read(true, "forced failure");

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(3, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
    EXPECT_FALSE(error.empty());
}

TEST_F(chip_ads78_test, bit_read_handles_empty_response)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_ERR);
    EXPECT_NE(error.find("insufficient data"), std::string::npos);
}

// ===== Additional ADC value tests =====

TEST_F(chip_ads78_test, bit_read_converts_quarter_scale_adc_value)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    // Quarter-scale: 1024
    bus->enqueue_read_payload({0x04, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    // Expected: (1024 * 2500) / 4096 = 625
    EXPECT_EQ(out_buffer[0], 0x71); // 625 & 0xFF = 0x71
    EXPECT_EQ(out_buffer[1], 0x02); // (625 >> 8) & 0xFF = 0x02
}

TEST_F(chip_ads78_test, bit_read_converts_three_quarter_scale_adc_value)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    // Three-quarter scale: 3072
    bus->enqueue_read_payload({0x0C, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    // Expected: (3072 * 2500) / 4096 = 1875
    EXPECT_EQ(out_buffer[0], 0x53); // 1875 & 0xFF = 0x53
    EXPECT_EQ(out_buffer[1], 0x07); // (1875 >> 8) & 0xFF = 0x07
}

TEST_F(chip_ads78_test, bit_read_converts_small_adc_value)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    // Small value: 16 (0x010)
    bus->enqueue_read_payload({0x00, 0x10});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    EXPECT_EQ(m_chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    // Expected: (16 * 2500) / 4096 = 9 (rounded down)
    EXPECT_EQ(out_buffer[0], 0x09);
    EXPECT_EQ(out_buffer[1], 0x00);
}

TEST_F(chip_ads78_test, bit_read_all_channels_independently)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    // Test all 8 channels with the same data
    for (int ch = 0; ch < 8; ch++) {
        bus->enqueue_read_payload({0x08, 0x00});
        out_buffer.clear();
        EXPECT_EQ(m_chip.bit_read(ch, 2, 0, in_buffer, out_buffer, error), HAS_OK);
        EXPECT_FALSE(error.empty() && out_buffer.empty());
    }
}

// ===== Destructor test =====

TEST_F(chip_ads78_test, destructor_is_default)
{
    auto bus = bind_test_bus();
    bus->set_read_result(HAS_OK);
    bus->enqueue_read_payload({0x08, 0x00});

    std::vector<uint8_t> in_buffer;
    std::vector<uint8_t> out_buffer;
    std::string          error;

    // Create and destroy chip
    {
        dev::chip_ads78  chip;
        mc::mutable_dict csr;
        csr["Address"] = static_cast<uint32_t>(0x48);
        chip.init(csr);
        chip.set_left_bus(bus);
        chip.set_host_bus(bus);
        EXPECT_EQ(chip.bit_read(0, 2, 0, in_buffer, out_buffer, error), HAS_OK);
    }
    // Destructor should complete without error
}

} // namespace