/*
 * .============.
 * // M A K E / \
 * // C++ DEV / \
 * // E A S Y / \/ \
 * ++ ----------. \/\ .
 * \\ \ \ /\ /
 * \\ \ \ /
 * \\ \ \ /
 * -============'
 *
 * Copyright (c) 2018 Hevake and contributors, all rights reserved.
 *
 * This file is part of cpp-tbox (https://github.com/cpp-main/cpp-tbox)
 * Use of this source code is governed by MIT license that can be found
 * in the LICENSE file in the root of the source tree. All contributing
 * project authors may be found in the CONTRIBUTORS.md file in the root
 * of the source tree.
 */
#include "common_loop.h"

#include <algorithm>
#include <tbox/base/defines.h>
#include <tbox/base/assert.h>
#include <tbox/base/wrapped_recorder.h>

#include "timer_event_impl.h"

namespace tbox {
namespace event {

namespace {
uint64_t GetCurrentSteadyClockMilliseconds()
{
 return std::chrono::duration_cast<std::chrono::milliseconds> \
 (std::chrono::steady_clock::now().time_since_epoch()).count();
}
}

int64_t CommonLoop::getWaitTime() const
{
 if (hasNextFunc())
 return 0;

 /// Get the top of minimum heap
 int64_t wait_time = -1;
 if (!timer_min_heap_.empty()) {
 wait_time = timer_min_heap_.front()->expired - GetCurrentSteadyClockMilliseconds();
 if (wait_time < 0) //! If expired is little than now, then we consider this timer invalid and trigger it immediately.
 wait_time = 0;
 }

 return wait_time;
}

void CommonLoop::handleExpiredTimers()
{
 RECORD_SCOPE();

 auto now = GetCurrentSteadyClockMilliseconds();

 while (!timer_min_heap_.empty()) {
 auto t = timer_min_heap_.front();
 //TBOX_ASSERT(t != nullptr);

 if (now < t->expired)
 break;

 int delay_ms = now - t->expired;
 if (delay_ms > (water_line_.timer_delay.count() / 1000000))
 LogNotice("timer delay over waterline: %d ms", delay_ms);

 auto tobe_run = t->cb;

 // swap first element and last element
 std::pop_heap(timer_min_heap_.begin(), timer_min_heap_.end(), TimerCmp());
 if (UNLIKELY(t->repeat == 1)) {
 // remove the last element
 timer_min_heap_.pop_back();
 timer_cabinet_.free(t->token);
 timer_object_pool_.free(t);
 } else {
 t->expired += t->interval;
 // push the last element to heap again
 std::push_heap(timer_min_heap_.begin(), timer_min_heap_.end(), TimerCmp());
 if (LIKELY(t->repeat != 0))
 --t->repeat;
 }

 //! Q: 为什么不在L68执行?
 //! A: 因为要尽可能地将回调放到最后执行。否则不满足测试 TEST(TimerEvent, DisableSelfInCallback)
 if (LIKELY(tobe_run)) {
 RECORD_SCOPE();
 ++cb_level_;
 tobe_run();
 --cb_level_;
 }
 }
}

void CommonLoop::exitLoop(const std::chrono::milliseconds &wait_time)
{
 if (sp_exit_timer_ != nullptr) {
 sp_exit_timer_->disable();
 CHECK_DELETE_RESET_OBJ(sp_exit_timer_);
 }

 if (wait_time.count() == 0) {
 stopLoop();
 } else {
 sp_exit_timer_ = newTimerEvent(__func__);
 sp_exit_timer_->initialize(wait_time, Event::Mode::kOneshot);
 sp_exit_timer_->setCallback([this] { stopLoop(); });
 sp_exit_timer_->enable();
 }
}

cabinet::Token CommonLoop::addTimer(uint64_t interval, uint64_t repeat, const TimerCallback &cb)
{
 TBOX_ASSERT(cb);

 auto now = GetCurrentSteadyClockMilliseconds();

 Timer *t = timer_object_pool_.alloc();
 TBOX_ASSERT(t != nullptr);

 t->token = this->timer_cabinet_.alloc(t);

 t->expired = now + interval;
 t->interval = interval;
 t->cb = cb;
 t->repeat = repeat;

 timer_min_heap_.push_back(t);
 std::push_heap(timer_min_heap_.begin(), timer_min_heap_.end(), TimerCmp());

 return t->token;
}

void CommonLoop::deleteTimer(const cabinet::Token& token)
{
 auto timer = timer_cabinet_.free(token);
 if (timer == nullptr)
 return;

#if 0
 timer_min_heap_.erase(timer);
 std::make_heap(timer_min_heap_.begin(), timer_min_heap_.end(), TimerCmp());
#else
 //! If we use the above method, it is likely to disrupt order, leading to a wide range of exchanges.
 //! This method will be a little better.
 timer->expired = 0;
 std::make_heap(timer_min_heap_.begin(), timer_min_heap_.end(), TimerCmp());
 std::pop_heap(timer_min_heap_.begin(), timer_min_heap_.end(), TimerCmp());
 timer_min_heap_.pop_back();
#endif

 run([this, timer] { timer_object_pool_.free(timer); }, __func__); //! Delete later, avoid delete itself
}

TimerEvent* CommonLoop::newTimerEvent(const std::string &what)
{
 return new TimerEventImpl(this, what);
}

}
}