#ifndef SINGLETONMANAGER_H
#define SINGLETONMANAGER_H

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

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

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

    /**
     * @brief 注銷清理回調（支持重復調用，安全可重入）
     * @param id 注冊時返回的 ID
     */
    void unregisterCleanup(const int id) {
        QMutexLocker locker(&m_mutex);
        m_funcs.erase(id); // 不存在的 ID 無副作用
    }

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

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

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

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

    QMutex m_mutex;                          // 保護回調列表的線程安全
    std::map<int, std::function<void()>> m_funcs; // 存儲清理回調（有序）
    int m_nextId{1};                         // 回調注冊 ID 生成器（從 1 開始，0 為無效 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 是可構造的（避免抽象類作為單例）
template<typename T>
constexpr bool is_singleton_valid_v = std::is_constructible_v<T> && !std::is_abstract_v<T>;

// 單例模板類：支持帶參數(shù)構造、自動注冊清理、線程安全訪問
template<typename T>
class Singleton {
    // 編譯期校驗：若 T 不可構造或為抽象類，直接報錯
    static_assert(is_singleton_valid_v<T>, 
                  "Singleton<T> requires T to be constructible and non-abstract");

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

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

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

    /**
     * @brief 獲取單例實例指針（線程安全）
     * @return T* 單例指針（非空，調試模式下為空會觸發(fā)斷言）
     * 注意：必須先調用 init() 初始化，否則調試模式斷言失敗，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 手動銷毀單例（主動釋放資源）
     * 特點：銷毀后可重新調用 init() 再次初始化，支持動態(tài)啟停
     */
    static void shutdown() {
        QMutexLocker locker(&mutex());
        if (instanceRef() != nullptr) {
            delete instanceRef();
            instanceRef() = nullptr;
            qDebug() << "[Singleton] " << typeid(T).name() << " shut down manually";
        }

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

    // 禁用默認構造/析構：禁止創(chuàng)建 Singleton 實例（僅通過靜態(tài)方法訪問）
    Singleton() = delete;
    ~Singleton() = delete;

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

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

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

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

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

/**
 * @def GET_SINGLETON_REF(Type)
 * @brief 獲取單例引用（調試模式下未初始化會觸發(fā)斷言）
 * 適用場景：確保單例必須存在的核心模塊（如配置管理）
 */
#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 獲取單例指針，若未初始化則返回替代值
 * 適用場景：需要降級策略的場景（如備用服務）
 */
#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>

// 示例單例類：網(wǎng)絡服務管理（支持信號槽，帶參數(shù)構造）
class MyService : public QObject {
    Q_OBJECT
public:
    /**
     * @brief 帶參數(shù)構造函數(shù)（單例的構造參數(shù)通過 Singleton::init() 傳遞）
     * @param serverUrl 服務端地址
     * @param port 服務端口
     * @param parent 父對象（建議設為 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è)務方法
    void doSomething() {
        qDebug() << "[MyService] Doing something with" << m_serverUrl << ":" << m_port;
        // 實際業(yè)務邏輯：如網(wǎng)絡請求、數(shù)據(jù)處理等
    }

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

private:
    QString m_serverUrl; // 服務端地址
    int m_port;          // 服務端口
};

#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 等依賴 Qt 環(huán)境初始化）
    QCoreApplication app(argc, argv);

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

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

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

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

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

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

        // 銷毀后可重新初始化
        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) {
        // 無參構造（若需帶參數(shù)，需調整設計，如全局配置）
        instanceRef() = new T();
        // 自動注冊清理回調
        if (regIdRef() == 0) {
            regIdRef() = SingletonManager::instance().registerCleanup([] {
                QMutexLocker locker(&mutex());
                delete instanceRef();
                instanceRef() = nullptr;
            });
        }
    }
    return instanceRef();
}

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

// 對應的 map 類型修改為：
std::map<std::pair<int, int>, std::function<void()>> m_funcs;

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

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

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