/**
 * @brief 時間輪類
 * 通過循環(huán)數組管理定時任務，模擬時鐘轉動。
 */
class TimerWheel{
    private:
        using WeakTask = std::weak_ptr<TimerTask>;
        using PtrTask = std::shared_ptr<TimerTask>;
        int _tick;//當前的秒針，走到哪里釋放哪里，釋放哪里就相當于執(zhí)行哪里的任務
        int _capacity;//表盤最大數量--其實就是最大延遲時間
        // 時間輪槽位：每個槽位是一個數組，存放該秒需要處理（或存活）的任務的 shared_ptr
        // 只要 shared_ptr 在這個數組里，引用計數就 > 0，任務就不會析構。
        std::vector<std::vector<PtrTask>> _wheel;
        // 索引表：通過 ID 快速找到任務對象。
        // 使用 weak_ptr 是為了不增加引用計數，避免干擾生命周期管理。
        std::unordered_map<uint64_t,WeakTask> _timers;
    private:
        // 從索引表中移除定時器記錄
        void RemoveTimer(uint64_t id){
            auto it = _timers.find(id);
            if(it != _timers.end()){
                _timers.erase(it);
            }
        } 
    public:
        TimerWheel():_capacity(60),_tick(0),_wheel(_capacity){}
        /**
         * @brief 添加定時任務
         * @param id 任務ID
         * @param delay 延遲多少秒執(zhí)行
         * @param cb 任務回調
         */
        void TimerAdd(uint64_t id,uint32_t delay,const TaskFunc &cb){
            // 1. 創(chuàng)建新任務對象，引用計數初始化為 1
            PtrTask pt(new TimerTask(id,delay,cb));
            // 2. 綁定 Release 回調，讓 Task 析構時能把自己從 _timers 里面刪掉
            pt->SetRelease(std::bind(&TimerWheel::RemoveTimer,this,id));
            // 3. 計算放置在時間輪的哪個槽位
            // 比如當前 tick 是 0，延遲 5 秒，則放在下標 5 的位置
            int pos = (_tick+delay)%_capacity;
            // 4. 將 shared_ptr 放入對應的槽位（引用計數 +1）
            _wheel[pos].push_back(pt);
            // 5. 記錄到索引表（weak_ptr 不增加引用計數）
            _timers[id] = WeakTask(pt);
        }
        /**
         * @brief 刷新定時任務（續(xù)命）
         * 類似于 TCP 的 KeepAlive，如果連接有活動，就重置它的超時時間。
         */
        void TimerRefresh(uint64_t id){
            auto it = _timers.find(id);
            if(it == _timers.end()){
                return;//沒找到定時任務
            }
            // 2. 嘗試將 weak_ptr 提升為 shared_ptr
            // 如果對象還沒析構，pt 就不為空
            PtrTask pt = it->second.lock();
            // 3. 重新計算新的槽位
            int delay = pt->DelayTime();
            int pos = (_tick + delay)%_capacity;
            // 4. 將 shared_ptr 再次加入新槽位
            // 注意：此時該任務對象可能同時存在于多個槽位中（舊槽位和新槽位）。
            // 只要還有一個槽位持有它，引用計數就不為0，它就不會析構。
            _wheel[pos].push_back(pt);
        }
        /**
         * @brief 取消定時任務
         */
        void TimerCancel(uint64_t id){
            auto it = _timers.find(id);
            if(it == _timers.end()){
                return;//沒找到定時任務
            }
            PtrTask pt = it->second.lock();
            if(pt)pt->Cancel();// 僅僅設置標志位，等待自然析構時不執(zhí)行回調
        }
        /**
         * @brief 驅動時間輪走動一格
         * 通常由一個每秒觸發(fā)一次的定時器（如 timerfd）調用
         */
        void RunTimerTask(){
            // 1. 秒針向前走一步
            _tick = (_tick + 1)%_capacity;
            // 2. 清空當前秒針指向的槽位
            // vector::clear() 會析構里面所有的 shared_ptr。
            // 如果某個 Task 的引用計數因此減為 0，就會調用 ~TimerTask()，從而執(zhí)行任務。
            // 如果該 Task 之前被 Refresh 過，它還會存在于后續(xù)的槽位中，引用計數 > 0，這里 clear 不會導致它析構。
            _wheel[_tick].clear();//清空指定位置的數組
        }
};

/**
 * @brief 定時器任務類
 * 封裝了一個具體的定時任務，利用 RAII 機制，
 * 當該對象被銷毀時（引用計數歸零），觸發(fā)任務執(zhí)行。
 */
class TimerTask{
    private:
        uint64_t _id;//定時器任務ID
        uint32_t _timeout;//定時器任務的超時時間(延遲時間)
        bool _canceled;//false 表示沒有被取消，true-表示被取消
        TaskFunc _task_cb;//定時器定時任務
        ReleaseFunc _release;//刪除TimerWheel中保存的定時器對象信息
    public:
        TimerTask(uint64_t id,uint32_t delay,const TaskFunc &cb):
            _id(id),_timeout(delay),_task_cb(cb){}
        /**
         * @brief 析構函數
         * 核心邏輯所在：當 shared_ptr 計數減為 0 時，對象析構。
         * 此時檢查是否被取消，如果沒有取消，則執(zhí)行定時任務。
         */
        ~TimerTask() {
            if (!_canceled && _task_cb) {
                _task_cb(); // 執(zhí)行任務
            }
            if (_release) {
                _release(); // 從時間輪的索引 map 中刪除自己
            }
        }
        // 設置任務取消狀態(tài)
        void Cancel(){_canceled = true;}
        // 設置清理回調（用于從 map 中移除記錄）
        void SetRelease(const ReleaseFunc &cb){_release = cb;}
        // 獲取延遲時間
        uint32_t DelayTime(){return _timeout;}
};