#ifndef SINGLETONMANAGER_H
#define SINGLETONMANAGER_H

#include <QMutex>
#include <functional>
#include <map>
#include <QObject> // 確保 Q_DISABLE_COPY_MOVE 可用

// 單例管理器：統(tǒng)一注冊(cè)/注銷(xiāo)/執(zhí)行單例清理回調(diào)
class SingletonManager {
public:
    // 管理器自身是單例（懶加載，線程安全）
    static SingletonManager &instance() {
        static SingletonManager inst; // C++11 后靜態(tài)局部變量初始化線程安全
        return inst;
    }

    /**
     * @brief 注冊(cè)單例清理回調(diào)
     * @param fn 清理函數(shù)（通常是刪除單例實(shí)例的 lambda）
     * @return 注冊(cè) ID（用于后續(xù)注銷(xiāo)），ID > 0
     */
    int registerCleanup(std::function<void()> fn) {
        QMutexLocker locker(&m_mutex); // 加鎖保證線程安全
        int id = m_nextId++;
        m_funcs.emplace(id, std::move(fn)); // 轉(zhuǎn)移函數(shù)所有權(quán)，避免拷貝開(kāi)銷(xiāo)
        return id;
    }

    /**
     * @brief 注銷(xiāo)清理回調(diào)（支持重復(fù)調(diào)用，安全可重入）
     * @param id 注冊(cè)時(shí)返回的 ID
     */
    void unregisterCleanup(const int id) {
        QMutexLocker locker(&m_mutex);
        m_funcs.erase(id); // 不存在的 ID 無(wú)副作用
    }

    /**
     * @brief 執(zhí)行所有注冊(cè)的清理回調(diào)（程序退出時(shí)調(diào)用）
     * 特點(diǎn)：拷貝回調(diào)列表后再執(zhí)行，避免回調(diào)中操作管理器導(dǎo)致死鎖
     */
    void cleanupAll() {
        std::map<int, std::function<void()>> copyFuncs;
        {
            // 局部作用域：釋放鎖后再執(zhí)行回調(diào)，提高并發(fā)效率
            QMutexLocker locker(&m_mutex);
            copyFuncs = m_funcs; // 拷貝回調(diào)列表
            m_funcs.clear();     // 清空原列表，避免重復(fù)執(zhí)行
        }

        // 按注冊(cè)順序執(zhí)行回調(diào)（map 是有序容器，key 遞增）
        for (auto &[id, func] : copyFuncs) {
            if (func) {
                try {
                    func(); // 執(zhí)行清理邏輯
                } catch (...) {
                    // 捕獲所有異常，避免單個(gè)單例清理失敗影響其他
                    qWarning() << "[SingletonManager] Cleanup failed for id:" << id;
                }
            }
        }
    }

private:
    // 私有構(gòu)造/析構(gòu)：禁止外部創(chuàng)建實(shí)例
    SingletonManager() = default;
    ~SingletonManager() = default;

    // 禁用拷貝/移動(dòng)：確保管理器全局唯一
    Q_DISABLE_COPY_MOVE(SingletonManager)

    QMutex m_mutex;                          // 保護(hù)回調(diào)列表的線程安全
    std::map<int, std::function<void()>> m_funcs; // 存儲(chǔ)清理回調(diào)（有序）
    int m_nextId{1};                         // 回調(diào)注冊(cè) ID 生成器（從 1 開(kāi)始，0 為無(wú)效 ID）
};

#endif // SINGLETONMANAGER_H

#ifndef SINGLETON_H
#define SINGLETON_H

#include <QMutexLocker>
#include <QCoreApplication>
#include <QDebug>
#include <type_traits>
#include <utility> // 用于 std::forward

#include "SingletonManager.h"

// 靜態(tài)斷言：確保 T 是可構(gòu)造的（避免抽象類(lèi)作為單例）
template<typename T>
constexpr bool is_singleton_valid_v = std::is_constructible_v<T> && !std::is_abstract_v<T>;

// 單例模板類(lèi)：支持帶參數(shù)構(gòu)造、自動(dòng)注冊(cè)清理、線程安全訪問(wèn)
template<typename T>
class Singleton {
    // 編譯期校驗(yàn)：若 T 不可構(gòu)造或?yàn)槌橄箢?lèi)，直接報(bào)錯(cuò)
    static_assert(is_singleton_valid_v<T>, 
                  "Singleton<T> requires T to be constructible and non-abstract");

public:
    /**
     * @brief 初始化單例（必須在調(diào)用 instance() 前執(zhí)行）
     * @tparam Args 構(gòu)造函數(shù)參數(shù)類(lèi)型
     * @param args 構(gòu)造函數(shù)參數(shù)（完美轉(zhuǎn)發(fā)，支持左值/右值）
     * 特點(diǎn)：自動(dòng)注冊(cè)清理回調(diào)到 SingletonManager，支持重復(fù)調(diào)用（僅首次有效）
     */
    template<typename... Args>
    static void init(Args &&... args) {
        QMutexLocker lockerInit(&mutex()); // 加鎖保證初始化線程安全
        if (instanceRef() != nullptr) {
            qWarning() << "[Singleton] " << typeid(T).name() << " has already been initialized";
            return;
        }

        // 完美轉(zhuǎn)發(fā)參數(shù)，創(chuàng)建單例實(shí)例（支持任意構(gòu)造參數(shù)）
        instanceRef() = new T(std::forward<Args>(args)...);

        // 注冊(cè)清理回調(diào)（僅首次初始化時(shí)注冊(cè)）
        if (regIdRef() == 0) {
            regIdRef() = SingletonManager::instance().registerCleanup([] {
                QMutexLocker lockerCleanup(&mutex());
                delete instanceRef(); // 釋放單例實(shí)例
                instanceRef() = nullptr; // 重置指針，避免野指針
                qDebug() << "[Singleton] " << typeid(T).name() << " cleaned up";
            });
        }
    }

    /**
     * @brief 獲取單例實(shí)例指針（線程安全）
     * @return T* 單例指針（非空，調(diào)試模式下為空會(huì)觸發(fā)斷言）
     * 注意：必須先調(diào)用 init() 初始化，否則調(diào)試模式斷言失敗，release 模式可能崩潰
     */
    static T *instance() {
        QMutexLocker locker(&mutex());
        Q_ASSERT_X(instanceRef() != nullptr, 
                   "Singleton::instance()", 
                   qPrintable(QString("%1 not initialized! Call Singleton<%1>::init() first.").arg(typeid(T).name())));
        return instanceRef();
    }

    /**
     * @brief 手動(dòng)銷(xiāo)毀單例（主動(dòng)釋放資源）
     * 特點(diǎn)：銷(xiāo)毀后可重新調(diào)用 init() 再次初始化，支持動(dòng)態(tài)啟停
     */
    static void shutdown() {
        QMutexLocker locker(&mutex());
        if (instanceRef() != nullptr) {
            delete instanceRef();
            instanceRef() = nullptr;
            qDebug() << "[Singleton] " << typeid(T).name() << " shut down manually";
        }

        // 注銷(xiāo)清理回調(diào)（避免重復(fù)銷(xiāo)毀）
        if (regIdRef() != 0) {
            SingletonManager::instance().unregisterCleanup(regIdRef());
            regIdRef() = 0;
        }
    }

    // 禁用默認(rèn)構(gòu)造/析構(gòu)：禁止創(chuàng)建 Singleton 實(shí)例（僅通過(guò)靜態(tài)方法訪問(wèn)）
    Singleton() = delete;
    ~Singleton() = delete;

    // 禁用拷貝/移動(dòng)：確保單例唯一性
    Singleton(const Singleton &) = delete;
    Singleton &operator=(const Singleton &) = delete;
    Singleton(Singleton &&) = delete;
    Singleton &operator=(Singleton &&) = delete;

private:
    /**
     * @brief 獲取單例實(shí)例引用（靜態(tài)局部變量，懶加載）
     * 注意：靜態(tài)局部變量初始化線程安全（C++11 標(biāo)準(zhǔn)）
     */
    static T *&instanceRef() {
        static T *inst = nullptr;
        return inst;
    }

    /**
     * @brief 獲取互斥鎖引用（靜態(tài)局部變量，懶加載）
     * 每個(gè)單例類(lèi)擁有獨(dú)立的互斥鎖，避免不同單例間鎖競(jìng)爭(zhēng)
     */
    static QMutex &mutex() {
        static QMutex m;
        return m;
    }

    /**
     * @brief 獲取清理回調(diào)注冊(cè) ID 引用
     * 用于跟蹤是否已注冊(cè)清理回調(diào)，避免重復(fù)注冊(cè)
     */
    static int &regIdRef() {
        static int id = 0;
        return id;
    }
};

/**
 * @def GET_SINGLETON(Type)
 * @brief 獲取單例指針（可能為 nullptr，需自行判空）
 * 適用場(chǎng)景：允許單例未初始化的場(chǎng)景（如可選功能模塊）
 */
#define GET_SINGLETON(Type) (Singleton<Type>::instance())

/**
 * @def GET_SINGLETON_REF(Type)
 * @brief 獲取單例引用（調(diào)試模式下未初始化會(huì)觸發(fā)斷言）
 * 適用場(chǎng)景：確保單例必須存在的核心模塊（如配置管理）
 */
#define GET_SINGLETON_REF(Type) ([]() -> Type & { \
    Type *p = Singleton<Type>::instance();       \
    Q_ASSERT_X(p != nullptr, "GET_SINGLETON_REF", "Singleton not initialized"); \
    return *p;                                   \
}())

/**
 * @def GET_SINGLETON_OR(Type, alt)
 * @brief 獲取單例指針，若未初始化則返回替代值
 * 適用場(chǎng)景：需要降級(jí)策略的場(chǎng)景（如備用服務(wù)）
 */
#define GET_SINGLETON_OR(Type, alt) (Singleton<Type>::instance() ? Singleton<Type>::instance() : (alt))

#endif // SINGLETON_H

#ifndef MYSERVICE_H
#define MYSERVICE_H

#include <QObject>
#include <QString>
#include <QDebug>

// 示例單例類(lèi)：網(wǎng)絡(luò)服務(wù)管理（支持信號(hào)槽，帶參數(shù)構(gòu)造）
class MyService : public QObject {
    Q_OBJECT
public:
    /**
     * @brief 帶參數(shù)構(gòu)造函數(shù)（單例的構(gòu)造參數(shù)通過(guò) Singleton::init() 傳遞）
     * @param serverUrl 服務(wù)端地址
     * @param port 服務(wù)端口
     * @param parent 父對(duì)象（建議設(shè)為 nullptr，避免生命周期沖突）
     */
    explicit MyService(const QString &serverUrl, int port, QObject *parent = nullptr) 
        : QObject(parent), m_serverUrl(serverUrl), m_port(port) {
        qDebug() << "[MyService] Initialized with URL:" << serverUrl << ", port:" << port;
    }

    ~MyService() override {
        qDebug() << "[MyService] Destructor called";
    }

    // 示例業(yè)務(wù)方法
    void doSomething() {
        qDebug() << "[MyService] Doing something with" << m_serverUrl << ":" << m_port;
        // 實(shí)際業(yè)務(wù)邏輯：如網(wǎng)絡(luò)請(qǐng)求、數(shù)據(jù)處理等
    }

signals:
    // 示例信號(hào)：如服務(wù)狀態(tài)變化
    void serviceReady();

private:
    QString m_serverUrl; // 服務(wù)端地址
    int m_port;          // 服務(wù)端口
};

#endif // MYSERVICE_H

#include <QCoreApplication>
#include <QTimer>
#include "SingletonManager.h"
#include "Singleton.h"
#include "MyService.h"

int main(int argc, char *argv[]) {
    // 1. 必須先創(chuàng)建 QCoreApplication（QMutex、QObject 等依賴(lài) Qt 環(huán)境初始化）
    QCoreApplication app(argc, argv);

    // 2. 連接 aboutToQuit 信號(hào)，程序退出時(shí)統(tǒng)一清理單例
    QObject::connect(&app, &QCoreApplication::aboutToQuit, []() {
        qDebug() << "\n[Main] Starting singleton cleanup...";
        SingletonManager::instance().cleanupAll();
        qDebug() << "[Main] Singleton cleanup finished";
    });

    // 3. 初始化單例（傳遞構(gòu)造參數(shù)，自動(dòng)注冊(cè)清理回調(diào)）
    Singleton<MyService>::init("http://example.com", 8080);

    // 4. 三種訪問(wèn)單例的方式
    // 方式1：獲取指針（需手動(dòng)判空，適合可選模塊）
    MyService *svcPtr = GET_SINGLETON(MyService);
    if (svcPtr) {
        svcPtr->doSomething();
    }

    // 方式2：獲取引用（調(diào)試模式斷言非空，適合核心模塊）
    MyService &svcRef = GET_SINGLETON_REF(MyService);
    svcRef.doSomething();

    // 方式3：獲取指針或替代值（適合降級(jí)策略）
    MyService *svcOr = GET_SINGLETON_OR(MyService, nullptr);
    if (svcOr) {
        svcOr->doSomething();
    }

    // 5. 示例：手動(dòng)銷(xiāo)毀單例（可選）
    QTimer::singleShot(2000, []() {
        qDebug() << "\n[Main] Shutting down MyService manually...";
        Singleton<MyService>::shutdown();

        // 銷(xiāo)毀后可重新初始化
        qDebug() << "[Main] Reinitializing MyService...";
        Singleton<MyService>::init("http://new-example.com", 9090);
        GET_SINGLETON_REF(MyService).doSomething();
    });

    // 6. 3秒后退出程序（觸發(fā) aboutToQuit 清理）
    QTimer::singleShot(3000, &app, &QCoreApplication::quit);

    return app.exec();
}

static T *instance() {
    QMutexLocker locker(&mutex());
    if (instanceRef() == nullptr) {
        // 無(wú)參構(gòu)造（若需帶參數(shù)，需調(diào)整設(shè)計(jì)，如全局配置）
        instanceRef() = new T();
        // 自動(dòng)注冊(cè)清理回調(diào)
        if (regIdRef() == 0) {
            regIdRef() = SingletonManager::instance().registerCleanup([] {
                QMutexLocker locker(&mutex());
                delete instanceRef();
                instanceRef() = nullptr;
            });
        }
    }
    return instanceRef();
}

// 修改 SingletonManager 的注冊(cè)接口，增加優(yōu)先級(jí)參數(shù)
int registerCleanup(std::function<void()> fn, int priority = 0) {
    QMutexLocker locker(&m_mutex);
    int id = m_nextId++;
    // 用 pair<priority, id> 作為 key，按優(yōu)先級(jí)降序排序（優(yōu)先級(jí)高的先清理）
    m_funcs.emplace(std::make_pair(-priority, id), std::move(fn));
    return id;
}

// 對(duì)應(yīng)的 map 類(lèi)型修改為：
std::map<std::pair<int, int>, std::function<void()>> m_funcs;

// 高優(yōu)先級(jí)（先清理）
Singleton<MyService>::initWithPriority(10, "http://example.com", 8080);

static T *&instanceRef() {
    thread_local T *inst = nullptr; // 線程局部變量，每個(gè)線程獨(dú)立
    return inst;
}

static QMutex &mutex() {
    thread_local QMutex m; // 每個(gè)線程獨(dú)立的鎖
    return m;
}