/*
 * .============.
 * // 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 <thread>
#include <unistd.h>
#include <signal.h>
#include <cinttypes>

#include <tbox/base/log.h>
#include <tbox/base/assert.h>
#include <tbox/base/defines.h>

#include "fd_event.h"
#include "stat.h"
#include "misc.h"
#include "timer_event.h"

namespace tbox {
namespace event {

using namespace std::chrono;

CommonLoop::~CommonLoop()
{
 TBOX_ASSERT(cb_level_ == 0);
 CHECK_DELETE_RESET_OBJ(sp_exit_timer_);
}

bool CommonLoop::isInLoopThread()
{
 std::lock_guard<std::recursive_mutex> g(lock_);
 return isInLoopThreadLockless();
}

bool CommonLoop::isRunning() const
{
 std::lock_guard<std::recursive_mutex> g(lock_);
 return isRunningLockless();
}

bool CommonLoop::isInLoopThreadLockless() const
{
 return std::this_thread::get_id() == loop_thread_id_;
}

bool CommonLoop::isRunningLockless() const
{
 return sp_run_read_event_ != nullptr;
}

void CommonLoop::runThisBeforeLoop()
{
 int event_fd = CreateEventFd();

 FdEvent *sp_read_event = newFdEvent("CommonLoop::sp_run_read_event_");
 if (!sp_read_event->initialize(event_fd, FdEvent::kReadEvent, Event::Mode::kPersist)) {
 close(event_fd);
 delete sp_read_event;
 return;
 }

 using std::placeholders::_1;
 sp_read_event->setCallback(std::bind(&CommonLoop::handleRunInLoopFunc, this));
 sp_read_event->enable();

 std::lock_guard<std::recursive_mutex> g(lock_);
 loop_thread_id_ = std::this_thread::get_id();
 run_event_fd_ = event_fd;
 sp_run_read_event_ = sp_read_event;

 if (!run_in_loop_func_queue_.empty())
 commitRunRequest();

 resetStat();
}

void CommonLoop::runThisAfterLoop()
{
 std::lock_guard<std::recursive_mutex> g(lock_);
 cleanupDeferredTasks();

 loop_thread_id_ = std::thread::id(); //! 清空 loop_thread_id_
 if (sp_run_read_event_ != nullptr) {
 CHECK_DELETE_RESET_OBJ(sp_run_read_event_);
 CHECK_CLOSE_RESET_FD(run_event_fd_);
 }
}

void CommonLoop::beginLoopProcess()
{
 loop_stat_start_ = steady_clock::now();
}

void CommonLoop::endLoopProcess()
{
 auto cost = steady_clock::now() - loop_stat_start_;
 ++loop_count_;
 loop_acc_cost_ += cost;
 if (loop_peak_cost_ < cost)
 loop_peak_cost_ = cost;

 if (cost > water_line_.loop_cost)
 LogNotice("loop_cost: %" PRIu64 " us", cost.count()/1000);
}

void CommonLoop::beginEventProcess()
{
 event_cb_stat_start_ = steady_clock::now();
}

void CommonLoop::endEventProcess(Event *event)
{
 auto cost = steady_clock::now() - event_cb_stat_start_;
 if (cost > water_line_.event_cb_cost)
 LogNotice("event_cb_cost: %" PRIu64 " us, what: '%s'",
 cost.count()/1000, event->what().c_str());
}

Stat CommonLoop::getStat() const
{
 Stat stat;
 using namespace std::chrono;
 stat.stat_time_us = duration_cast<microseconds>(steady_clock::now() - whole_stat_start_).count();

 stat.loop_count = loop_count_;
 stat.loop_acc_cost_us = duration_cast<microseconds>(loop_acc_cost_).count();
 stat.loop_peak_cost_us = duration_cast<microseconds>(loop_peak_cost_).count();

 stat.run_in_loop_peak_num = run_in_loop_peak_num_;
 stat.run_next_peak_num = run_next_peak_num_;

 return stat;
}

void CommonLoop::resetStat()
{
 whole_stat_start_ = loop_stat_start_ = steady_clock::now();

 loop_count_ = 0;
 loop_acc_cost_ = nanoseconds::zero();
 loop_peak_cost_ = nanoseconds::zero();

 run_in_loop_peak_num_ = 0;
 run_next_peak_num_ = 0;
}

void CommonLoop::cleanup()
{
 cleanupDeferredTasks();
}

}
}