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

#include "dependent_object_registry.h"

#include <algorithm>

namespace dev {

// 单例实例的静态变量
static std::unique_ptr<device_manager> s_instance = nullptr;
#ifndef __ZEPHYR__
static std::mutex s_instance_mutex;
#endif

device_manager& device_manager::get_instance()
{
#ifndef __ZEPHYR__
    std::lock_guard<std::mutex> lock(s_instance_mutex);
#endif
    if (!s_instance) {
        s_instance = std::unique_ptr<device_manager>(new device_manager());
    }
    return *s_instance;
}

device_manager::device_manager()
{
    init_factory_maps();
}

void device_manager::init_factory_maps()
{
    // 通用chip工厂函数
    m_chip_factories["Pca9545"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_pca9545>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Pca9544"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_pca9544>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Pca9555"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_pca9555>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Ina"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_ina>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Chip"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
        const bool switch_supported = csr_data.contains("SwitchSupported") && csr_data["SwitchSupported"].as<bool>();
        std::shared_ptr<chip_base> ptr =
            switch_supported ? std::make_shared<chip_mcu_switch>() : std::make_shared<chip_base>();
#else
        std::shared_ptr<chip_base> ptr = std::make_shared<chip_base>();
#endif
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Lm75"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_lm75>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

#ifndef __ZEPHYR__
    m_chip_factories["Ads78"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_ads78>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Smc"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_smc>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["CpldRegister"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_cpld_register>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };
#endif

    m_chip_factories["Eeprom"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_eeprom>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    // CSR1专用chip工厂函数
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
    m_chip_factories["JtagSwitch"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_jtag_switch>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["CanbusChip"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_canbus_chip>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Cpld"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_cpld>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["CpldChip"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_cpld_chip>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["SPIFlash"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_spi_flash>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Vrd"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_vrd>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };

    m_chip_factories["Rtc"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
        auto ptr = std::make_shared<chip_rtc>();
        if (ptr && ptr->init(csr_data)) {
            return ptr;
        }
        return nullptr;
    };
#endif

    // 通用bus工厂函数
    m_bus_factories["I2c"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_i2c>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("I2c");
            return ptr;
        }
        return nullptr;
    };

#ifndef __ZEPHYR__
    m_bus_factories["Hisport"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_hisport>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("Hisport");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["LocalBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_localbus>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("LocalBus");
            return ptr;
        }
        return nullptr;
    };

    // JtagOverLocalBus 的 CSR2 插件无条件构建,内部总线与其基类同属 CSR1/CSR2 共用,
    // 因此工厂不再跟随 unidev 门控,避免 unidev=false 时 create_bus 找不到实现。
    m_bus_factories["JtagOverLocalBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_jtag_over_localbus>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("JtagOverLocalBus");
            return ptr;
        }
        return nullptr;
    };

    // ADC 为 CSR2 通用 bus 驱动(drivers/bus/adc),内部总线随 CSR1/CSR2 共用,
    // 工厂不再跟随 unidev 门控,避免 unidev=false 时 create_bus 找不到 "Adc" 实现。
    m_bus_factories["Adc"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_adc>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("Adc");
            return ptr;
        }
        return nullptr;
    };
#endif

    m_bus_factories["I2cMux"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_i2c_mux>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("I2cMux");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["UartBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_uart>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("UartBus");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["Can"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_can>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("Can");
            return ptr;
        }
        return nullptr;
    };

    // CSR1专用bus工厂函数
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
    m_bus_factories["JtagMux"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_jtag_mux>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("JtagMux");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["Gpio"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_gpio>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("Gpio");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["JtagOverGpio"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_jtag_over_gpio>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("JtagOverGpio");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["Jtag"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_jtag>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("Jtag");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["InnerBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_innerbus>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("InnerBus");
            return ptr;
        }
        return nullptr;
    };

#if COMPONENT_DRIVERS_ENABLE_CHIPV2
    m_bus_factories["JtagOverHisport"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_jtag_over_hisport>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("JtagOverHisport");
            return ptr;
        }
        return nullptr;
    };
#endif
#endif

    // CSR2 over-hisport bus factory(CSR1/CSR2 共用)
#if COMPONENT_DRIVERS_ENABLE_CHIPV2
    m_bus_factories["I2cOverLocalBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_i2c_over_localbus>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("I2cOverLocalBus");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["I3cOverLocalBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_i3c_over_localbus>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("I3cOverLocalBus");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["I2cOverHisport"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_i2c_over_hisport>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("I2cOverHisport");
            return ptr;
        }
        return nullptr;
    };

    m_bus_factories["SPIOverHisport"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
        auto ptr = std::make_shared<bus_spi_over_hisport>();
        if (ptr && ptr->init(csr_data)) {
            ptr->set_class_name("SPIOverHisport");
            return ptr;
        }
        return nullptr;
    };
#endif
}

std::shared_ptr<chip_base> device_manager::create_chip(const std::string& object_name, const std::string& class_name,
                                                       mc::mutable_dict& csr_data)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    try {
        if (csr_data.empty()) {
            MC_THROW(mc::invalid_op_exception, "csr_data is empty");
        }
        // 检查对象是否已存在
        if (m_chip_table.find(object_name) != m_chip_table.end()) {
            return m_chip_table[object_name];
        }

        // 查找对应的工厂函数
        auto factory_it = m_chip_factories.find(class_name);
        if (factory_it == m_chip_factories.end()) {
            elog("Unsupported chip type: ${type}", ("type", class_name));
            return nullptr;
        }

        // 使用工厂函数创建对象
        auto chip_ptr = factory_it->second(csr_data);
        if (chip_ptr) {
            // 创建即写入类型名:拓扑构建期就可能触发 get_topo_path()(ScannerMergeRegistry /
            // SmcDfxMergeRegistry 的合并键组成部分),此时 get_class_name()
            // 对多数 chip 返回空、依赖 m_class_name。若不在此先行设置,topo_path 会被
            // call_once 永久缓存为缺失类名的错误值。
            chip_ptr->set_class_name(class_name);
            m_chip_table[object_name] = chip_ptr;
            return chip_ptr;
        } else {
            elog("Failed to create chip object: ${name}, type: ${type}", ("name", object_name)("type", class_name));
            return nullptr;
        }
    } catch (const std::exception& e) {
        elog("Exception creating chip object: ${name}, error: ${error}", ("name", object_name)("error", e.what()));
        return nullptr;
    }
}

std::shared_ptr<bus_base> device_manager::create_bus(const std::string& object_name, const std::string& class_name,
                                                     mc::mutable_dict& csr_data)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    try {
        if (csr_data.empty()) {
            MC_THROW(mc::invalid_op_exception, "csr_data is empty");
        }
        // 检查对象是否已存在
        if (m_bus_table.find(object_name) != m_bus_table.end()) {
            return m_bus_table[object_name];
        }

        // 查找对应的工厂函数
        auto factory_it = m_bus_factories.find(class_name);
        if (factory_it == m_bus_factories.end()) {
            elog("Unsupported bus type: ${type}", ("type", class_name));
            return nullptr;
        }

        // 使用工厂函数创建对象
        auto bus_ptr = factory_it->second(csr_data);
        if (bus_ptr) {
            m_bus_table[object_name] = bus_ptr;
            return bus_ptr;
        } else {
            elog("Failed to create bus object: ${name}, type: ${type}", ("name", object_name)("type", class_name));
            return nullptr;
        }
    } catch (const std::exception& e) {
        elog("Exception creating bus object: ${name}, error: ${error}", ("name", object_name)("error", e.what()));
        return nullptr;
    }
}

std::optional<object_type> device_manager::get_object_type(const std::string& class_name) const
{
    std::lock_guard<std::mutex> lock(m_mutex);
    if (m_bus_factories.find(class_name) != m_bus_factories.end()) {
        return object_type::bus;
    }
    if (m_chip_factories.find(class_name) != m_chip_factories.end()) {
        return object_type::chip;
    }
    return std::nullopt;
}

std::variant<std::shared_ptr<chip_base>, std::shared_ptr<bus_base>> device_manager::find_object(const std::string& name,
                                                                                                object_type        type)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    try {
        switch (type) {
            case object_type::chip: {
                auto it = m_chip_table.find(name);
                if (it != m_chip_table.end()) {
                    return it->second;
                }
                break;
            }
            case object_type::bus: {
                auto it = m_bus_table.find(name);
                if (it != m_bus_table.end()) {
                    return it->second;
                }
                break;
            }
            default:
                elog("Unsupported object type: ${type}", ("type", static_cast<int>(type)));
                break;
        }

        dlog("Object not found: ${name}, type: ${type}", ("name", name)("type", static_cast<int>(type)));
        return std::shared_ptr<chip_base>(nullptr); // 返回空的shared_ptr作为默认值
    } catch (const std::exception& e) {
        elog("Exception finding object: ${name}, error: ${error}", ("name", name)("error", e.what()));
        return std::shared_ptr<chip_base>(nullptr);
    }
}

bool device_manager::remove_object(const std::string& name, object_type type)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    try {
        switch (type) {
            case object_type::chip: {
                auto it = m_chip_table.find(name);
                if (it != m_chip_table.end()) {
                    m_chip_table.erase(it);
                    return true;
                }
                break;
            }
            case object_type::bus: {
                auto it = m_bus_table.find(name);
                if (it != m_bus_table.end()) {
                    m_bus_table.erase(it);
                    return true;
                }
                break;
            }
            default:
                elog("Unsupported object type: ${type}", ("type", static_cast<int>(type)));
                return false;
        }

        wlog("Object to be deleted does not exist: ${name}, type: ${type}",
             ("name", name)("type", static_cast<int>(type)));
        return false;
    } catch (const std::exception& e) {
        elog("Exception deleting object: ${name}, error: ${error}", ("name", name)("error", e.what()));
        return false;
    }
}

void device_manager::clear_all()
{
    std::lock_guard<std::mutex> lock(m_mutex);
    try {
        size_t chip_count = m_chip_table.size();
        size_t bus_count  = m_bus_table.size();

        m_chip_table.clear();
        m_bus_table.clear();

        dlog("Cleared all object tables, deleted ${chip_count} chip objects, ${bus_count} bus objects",
             ("chip_count", chip_count)("bus_count", bus_count));
    } catch (const std::exception& e) {
        elog("Exception clearing object tables: ${error}", ("error", e.what()));
    }
}

} // namespace dev

// ===== DependentObjectRegistry 实现 =====
// 注:实现放在 manager.cpp 而非独立文件,确保在所有构建形态(meson/bingo/conan 增量构建)
// 中都随 internal 库一起编译,避免新增源文件未被构建配置收录导致的链接失败

namespace dev {

DependentObjectRegistry& DependentObjectRegistry::instance()
{
    static DependentObjectRegistry s_instance;
    return s_instance;
}

void DependentObjectRegistry::register_object(const std::string& chip_name, const std::string& object_name)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    auto&                       objects = m_map[chip_name];
    if (std::find(objects.begin(), objects.end(), object_name) == objects.end()) {
        objects.push_back(object_name);
    }
}

void DependentObjectRegistry::unregister_object(const std::string& chip_name, const std::string& object_name)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    auto                        it = m_map.find(chip_name);
    if (it == m_map.end()) {
        // chip 可能已无依赖对象但仍有暂停记录(暂停期间对象被销毁),一并清理
        auto pit = m_paused_map.find(chip_name);
        if (pit != m_paused_map.end()) {
            auto& records = pit->second;
            records.erase(std::remove_if(records.begin(), records.end(),
                                         [&object_name](const auto& rec) {
                return rec.first == object_name;
            }),
                          records.end());
            if (records.empty()) {
                m_paused_map.erase(pit);
            }
        }
        return;
    }
    auto& objects = it->second;
    objects.erase(std::remove(objects.begin(), objects.end(), object_name), objects.end());
    if (objects.empty()) {
        m_map.erase(it);
    }

    // 同步清理该对象的暂停记录(对象销毁后记录失效)
    auto pit = m_paused_map.find(chip_name);
    if (pit != m_paused_map.end()) {
        auto& records = pit->second;
        records.erase(std::remove_if(records.begin(), records.end(),
                                     [&object_name](const auto& rec) {
            return rec.first == object_name;
        }),
                      records.end());
        if (records.empty()) {
            m_paused_map.erase(pit);
        }
    }
}

std::vector<std::string> DependentObjectRegistry::get_objects(const std::string& chip_name) const
{
    std::lock_guard<std::mutex> lock(m_mutex);
    auto                        it = m_map.find(chip_name);
    if (it == m_map.end()) {
        return {};
    }
    return it->second;
}

} // namespace dev

namespace dev {

void DependentObjectRegistry::record_paused(const std::string& chip_name, const std::string& object_name,
                                            uint8_t original_state)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    auto&                       records = m_paused_map[chip_name];
    for (auto& rec : records) {
        if (rec.first == object_name) {
            return; // 已记录,幂等
        }
    }
    records.emplace_back(object_name, original_state);
}

std::vector<std::pair<std::string, uint8_t>> DependentObjectRegistry::take_paused(const std::string& chip_name)
{
    std::lock_guard<std::mutex> lock(m_mutex);
    auto                        it = m_paused_map.find(chip_name);
    if (it == m_paused_map.end()) {
        return {};
    }
    auto records = std::move(it->second);
    m_paused_map.erase(it);
    return records;
}

bool DependentObjectRegistry::has_paused_record(const std::string& chip_name, const std::string& object_name) const
{
    std::lock_guard<std::mutex> lock(m_mutex);
    auto                        it = m_paused_map.find(chip_name);
    if (it == m_paused_map.end()) {
        return false;
    }
    const auto& records = it->second;
    return std::any_of(records.begin(), records.end(), [&object_name](const auto& rec) {
        return rec.first == object_name;
    });
}

bool DependentObjectRegistry::has_paused_records(const std::string& chip_name) const
{
    std::lock_guard<std::mutex> lock(m_mutex);
    auto                        it = m_paused_map.find(chip_name);
    return it != m_paused_map.end() && !it->second.empty();
}

} // namespace dev