/*
 *     .============.
 *    //  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 "context_imp.h"

#include <sstream>
#include <iomanip>
#include <sys/time.h>

#include <tbox/base/json.hpp>
#include <tbox/base/log.h>
#include <tbox/base/assert.h>
#include <tbox/base/version.h>
#include <tbox/base/catch_throw.h>
#include <tbox/util/string.h>
#include <tbox/util/json.h>
#include <tbox/util/fs.h>
#include <tbox/terminal/session.h>
#include <tbox/terminal/helper.h>

#include "main.h"
#include "module.h"

namespace tbox {
namespace main {

namespace {
std::string ToString(const std::chrono::milliseconds msec)
{
    uint64_t ms = msec.count();

    constexpr auto ms_per_sec   = 1000;
    constexpr auto ms_per_min   = 60 * ms_per_sec;
    constexpr auto ms_per_hour  = 60 * ms_per_min;
    constexpr auto ms_per_day   = 24 * ms_per_hour;

    auto days = ms / ms_per_day;
    auto ms_in_day = ms % ms_per_day;
    auto hours = ms_in_day / ms_per_hour;
    auto ms_in_hour = ms_in_day % ms_per_hour;
    auto mins = ms_in_hour / ms_per_min;
    auto ms_in_min = ms_in_hour % ms_per_min;
    auto secs = ms_in_min / ms_per_sec;
    auto msecs = ms_in_min % ms_per_sec;

    using namespace std;
    ostringstream oss;

    oss << days << ' ';
    oss << setfill('0');
    oss << setw(2) << hours << ':'
        << setw(2) << mins << ':'
        << setw(2) << secs << '.'
        << setw(3) << msecs;

    return oss.str();
}
}

ContextImp::ContextImp() :
    sp_loop_(event::Loop::New()),
    sp_thread_pool_(new eventx::ThreadPool(sp_loop_)),
    sp_timer_pool_(new eventx::TimerPool(sp_loop_)),
    sp_async_(new eventx::Async(sp_thread_pool_)),
    sp_terminal_(new terminal::Terminal(sp_loop_)),
    sp_telnetd_(new terminal::Telnetd(sp_loop_, sp_terminal_)),
    sp_tcp_rpc_(new terminal::TcpRpc(sp_loop_, sp_terminal_)),
    sp_coroutine_(new coroutine::Scheduler(sp_loop_)),
    start_time_point_(std::chrono::steady_clock::now())
{
    TBOX_ASSERT(sp_loop_ != nullptr);
    TBOX_ASSERT(sp_thread_pool_ != nullptr);
    TBOX_ASSERT(sp_timer_pool_ != nullptr);
    TBOX_ASSERT(sp_async_ != nullptr);
    TBOX_ASSERT(sp_terminal_ != nullptr);
    TBOX_ASSERT(sp_telnetd_ != nullptr);
    TBOX_ASSERT(sp_tcp_rpc_ != nullptr);
    TBOX_ASSERT(sp_coroutine_ != nullptr);
}

ContextImp::~ContextImp()
{
    delete sp_coroutine_;
    delete sp_tcp_rpc_;
    delete sp_telnetd_;
    delete sp_terminal_;
    delete sp_async_;
    delete sp_timer_pool_;
    delete sp_thread_pool_;
    delete sp_loop_;
}

void ContextImp::fillDefaultConfig(Json &cfg) const
{
    cfg["thread_pool"] = R"({"min":0, "max":1})"_json;
}

bool ContextImp::initialize(const char* proc_name, const Json &cfg, const Args &args, Module *module)
{
    TBOX_ASSERT(module != nullptr);
    module_ = module;
    js_conf_ = &cfg;
    wp_args_ = &args;

    if (util::json::HasObjectField(cfg, "loop")) {
        auto &js_loop = cfg["loop"];
        initLoop(js_loop);
    }

    if (!util::json::HasObjectField(cfg, "thread_pool")) {
        LogWarn("cfg.thread_pool not found");
        return false;
    }

    auto &js_thread_pool = cfg["thread_pool"];
    if (!initThreadPool(js_thread_pool))
        return false;

    {
        std::ostringstream oss;
        oss <<
            "\r\n"
            "Welcome to " << util::fs::Basename(proc_name) << " main terminal!\r\n"
            "\r\n"
            "This program is based on cpp-tbox which designed by Hevake Lee.\r\n"
            "Repository: https://github.com/cpp-main/cpp-tbox\r\n"
            "\r\n"
            R"(      .============.      )""\r\n"
            R"(     //  M A K E  / \     )""\r\n"
            R"(    //  C++ DEV  /   \    )""\r\n"
            R"(   //  E A S Y  /  \/ \   )""\r\n"
            R"(  ++ ----------.  \/\  .  )""\r\n"
            R"(   \\     \     \ /\  /   )""\r\n"
            R"(    \\     \     \   /    )""\r\n"
            R"(     \\     \     \ /     )""\r\n"
            R"(      -============'      )""\r\n"
            "\r\n";

        sp_terminal_->setWelcomeText(oss.str());
    }

    if (util::json::HasObjectField(cfg, "telnetd")) {
        auto &js_telnetd = cfg["telnetd"];
        initTelnetd(js_telnetd);
    }

    if (util::json::HasObjectField(cfg, "tcp_rpc")) {
        auto &js_tcp_rpc = cfg["tcp_rpc"];
        initRpc(js_tcp_rpc);
    }

    initShell();

    return true;
}

bool ContextImp::initLoop(const Json &js)
{
    if (util::json::HasObjectField(js, "water_line")) {
        auto &js_water_line = js["water_line"];
        auto &water_line = sp_loop_->water_line();

        int value = 0;
        if (util::json::GetField(js_water_line, "run_in_loop_queue_size", value))
            water_line.run_in_loop_queue_size = value;

        if (util::json::GetField(js_water_line, "run_next_queue_size", value))
            water_line.run_next_queue_size = value;

        if (util::json::GetField(js_water_line, "run_in_loop_delay", value))
            water_line.run_in_loop_delay = std::chrono::microseconds(value);

        if (util::json::GetField(js_water_line, "run_next_delay", value))
            water_line.run_next_delay = std::chrono::microseconds(value);

        if (util::json::GetField(js_water_line, "loop_cost", value))
            water_line.loop_cost = std::chrono::microseconds(value);

        if (util::json::GetField(js_water_line, "event_cb_cost", value))
            water_line.event_cb_cost = std::chrono::microseconds(value);

        if (util::json::GetField(js_water_line, "run_cb_cost", value))
            water_line.run_cb_cost = std::chrono::microseconds(value);

        if (util::json::GetField(js_water_line, "wake_delay", value))
            water_line.wake_delay = std::chrono::microseconds(value);

        if (util::json::GetField(js_water_line, "timer_delay", value))
            water_line.timer_delay = std::chrono::microseconds(value);
    }

    return true;
}

bool ContextImp::initThreadPool(const Json &js)
{
    int thread_pool_min = 0, thread_pool_max = 0;
    if (!util::json::GetField(js, "min", thread_pool_min) ||
        !util::json::GetField(js, "max", thread_pool_max)) {
        LogWarn("in cfg.thread_pool, min or max is not number");
        return false;
    }

    if (!sp_thread_pool_->initialize(thread_pool_min, thread_pool_max))
        return false;

    return true;
}

bool ContextImp::initTelnetd(const Json &js)
{
    std::string telnetd_bind;
    if (util::json::GetField(js, "bind", telnetd_bind)) {
      if (sp_telnetd_->initialize(telnetd_bind))
        telnetd_init_ok = true;
    }
    return true;
}

bool ContextImp::initRpc(const Json &js)
{
    std::string tcp_rpc_bind;
    if (util::json::GetField(js, "bind", tcp_rpc_bind)) {
        if (sp_tcp_rpc_->initialize(tcp_rpc_bind))
            tcp_rpc_init_ok = true;
    }
    return true;
}

bool ContextImp::start()
{
    if (telnetd_init_ok)
        sp_telnetd_->start();

    if (tcp_rpc_init_ok)
        sp_tcp_rpc_->start();

    return true;
}

void ContextImp::stop()
{
    if (tcp_rpc_init_ok)
        sp_tcp_rpc_->stop();

    if (telnetd_init_ok)
        sp_telnetd_->stop();
}

void ContextImp::cleanup()
{
    sp_coroutine_->cleanup();
    sp_tcp_rpc_->cleanup();
    sp_telnetd_->cleanup();
    sp_timer_pool_->cleanup();
    sp_thread_pool_->cleanup();
    sp_loop_->cleanup();

    LogInfo("running_time: %s", ToString(running_time()).c_str());
}

std::chrono::milliseconds ContextImp::running_time() const
{
    auto now = std::chrono::steady_clock::now();
    return std::chrono::duration_cast<std::chrono::milliseconds>(now - start_time_point_);
}

std::chrono::system_clock::time_point ContextImp::start_time_point() const
{
    auto steady_clock_now = std::chrono::steady_clock::now();
    auto system_clock_now = std::chrono::system_clock::now();
    return system_clock_now - (steady_clock_now - start_time_point_);
}

void ContextImp::initShell()
{
    using namespace terminal;
    TerminalNodes *wp_nodes = sp_terminal_;

    auto ctx_node = wp_nodes->createDirNode("This is Context directory");
    wp_nodes->mountNode(wp_nodes->rootNode(), ctx_node, "ctx");

    {
        auto loop_node = wp_nodes->createDirNode("This is Loop directory");
        wp_nodes->mountNode(ctx_node, loop_node, "loop");

        {
            auto water_line_node = wp_nodes->createDirNode("This is water line directory");
            wp_nodes->mountNode(loop_node, water_line_node, "wl");

            #define ADD_WATERLINE_SIZE_FUNC_NODE(field) \
            {\
                terminal::IntegerFuncNodeProfile profile; \
                profile.get_func = [this] { return sp_loop_->water_line().field; }; \
                profile.set_func = [this] (int value) { sp_loop_->water_line().field = value; return true; }; \
                profile.min_value = 0; \
                terminal::AddFuncNode(*wp_nodes, water_line_node, #field, profile); \
            }

            ADD_WATERLINE_SIZE_FUNC_NODE(run_in_loop_queue_size);
            ADD_WATERLINE_SIZE_FUNC_NODE(run_next_queue_size);

            #define ADD_WATERLINE_TIME_FUNC_NODE(field) \
            {\
                terminal::IntegerFuncNodeProfile profile; \
                profile.get_func = [this] { return sp_loop_->water_line().field.count()/1000; }; \
                profile.set_func = [this] (int value) { sp_loop_->water_line().field= std::chrono::microseconds(value); return true; }; \
                profile.min_value = 0; \
                terminal::AddFuncNode(*wp_nodes, water_line_node, #field, profile); \
            }

            ADD_WATERLINE_TIME_FUNC_NODE(run_in_loop_delay);
            ADD_WATERLINE_TIME_FUNC_NODE(run_next_delay);
            ADD_WATERLINE_TIME_FUNC_NODE(loop_cost);
            ADD_WATERLINE_TIME_FUNC_NODE(event_cb_cost);
            ADD_WATERLINE_TIME_FUNC_NODE(run_cb_cost);
            ADD_WATERLINE_TIME_FUNC_NODE(wake_delay);
            ADD_WATERLINE_TIME_FUNC_NODE(timer_delay);
        }

        {
            auto loop_stat_node = wp_nodes->createDirNode();
            wp_nodes->mountNode(loop_node, loop_stat_node, "stat");

            auto loop_stat_print_node = wp_nodes->createFuncNode(
                [this] (const Session &s, const Args &args) {
                    std::stringstream ss;
                    ss << sp_loop_->getStat();
                    std::string txt = ss.str();
                    util::string::Replace(txt, "\n", "\r\n");
                    s.send(txt);
                    (void)args;
                },
                "print Loop's stat data"
            );
            wp_nodes->mountNode(loop_stat_node, loop_stat_print_node, "print");

            auto loop_stat_reset_node = wp_nodes->createFuncNode(
                [this] (const Session &s, const Args &args) {
                    std::stringstream ss;
                    sp_loop_->resetStat();
                    ss << "done\r\n";
                    s.send(ss.str());
                    (void)args;
                },
                "reset Loop's stat data"
            );
            wp_nodes->mountNode(loop_stat_node, loop_stat_reset_node, "reset");

            {
                auto func_node = wp_nodes->createFuncNode(
                    [this] (const Session &s, const Args &args) {
                        s.send(ToString(running_time()));
                        s.send("\r\n");
                        (void)args;
                    },
                    "Print running times"
                );
                wp_nodes->mountNode(ctx_node, func_node, "running_time");
            }
        }

        {
            auto func_node = wp_nodes->createFuncNode(
                [this] (const Session &s, const Args &args) {
                    std::stringstream ss;
                    auto ts = std::chrono::duration_cast<std::chrono::milliseconds>(start_time_point().time_since_epoch()).count();
                    {
                        time_t sec = ts / 1000;
                        struct tm tm;
                        localtime_r(&sec, &tm);
                        char tmp[20];
                        strftime(tmp, sizeof(tmp), "%Y-%m-%d %H:%M:%S", &tm);
                        ss << tmp << '.' << ts % 1000 << "\r\n";
                    }

                    s.send(ss.str());
                    (void)args;
                },
                "Print start time point"
            );
            wp_nodes->mountNode(ctx_node, func_node, "start_time");
        }

    }

    {
        auto threadpool_node = wp_nodes->createDirNode("This is ThreadPool directory");
        wp_nodes->mountNode(ctx_node, threadpool_node, "thread_pool");

        {
            //! 打印线程池快照
            auto func_node = wp_nodes->createFuncNode(
                [this] (const Session &s, const Args &args) {
                    std::ostringstream oss;
                    auto snapshot = sp_thread_pool_->snapshot();
                    oss << "thread_num: " << snapshot.thread_num << "\r\n";
                    oss << "idle_thread_num: " << snapshot.idle_thread_num << "\r\n";
                    oss << "undo_task_num:";
                    for (size_t i = 0; i < THREAD_POOL_PRIO_SIZE; ++i)
                        oss << " " << snapshot.undo_task_num[i];
                    oss << "\r\n";
                    oss << "doing_task_num: " << snapshot.doing_task_num << "\r\n";
                    oss << "undo_task_peak_num: " << snapshot.undo_task_peak_num << "\r\n";
                    s.send(oss.str());
                    (void)args;
                },
                "Print thread pool's snapshot"
            );
            wp_nodes->mountNode(threadpool_node, func_node, "snapshot");
        }
    }

    {
        auto info_node = wp_nodes->createDirNode("Information directory");
        wp_nodes->mountNode(wp_nodes->rootNode(), info_node, "info");

        {
            auto func_node = wp_nodes->createFuncNode(
                [] (const Session &s, const Args &args) {
                    std::stringstream ss;
                    int major = 0, minor = 0, rev = 0, build = 0;
                    GetAppVersion(major, minor, rev, build);
                    ss << 'v' << major << '.' << minor << '.' << rev << '_' << build << "\r\n";
                    s.send(ss.str());
                    (void)args;
                },
                "Print app version"
            );
            wp_nodes->mountNode(info_node, func_node, "app_ver");
        }
        {
            auto func_node = wp_nodes->createFuncNode(
                [] (const Session &s, const Args &args) {
                    std::stringstream ss;
                    int major = 0, minor = 0, rev = 0;
                    GetTboxVersion(major, minor, rev);
                    ss << 'v' << major << '.' << minor << '.' << rev << "\r\n";
                    s.send(ss.str());
                    (void)args;
                },
                "Print tbox version"
            );
            wp_nodes->mountNode(info_node, func_node, "tbox_ver");
        }
        {
            auto func_node = wp_nodes->createFuncNode(
                [] (const Session &s, const Args &args) {
                    std::stringstream ss;
                    ss << GetAppBuildTime() << "\r\n";
                    s.send(ss.str());
                    (void)args;
                },
                "Print buildtime"
            );
            wp_nodes->mountNode(info_node, func_node, "build_time");
        }
        {
            auto func_node = wp_nodes->createFuncNode(
                [] (const Session &s, const Args &args) {
                    std::stringstream ss;
                    ss << GetAppDescribe() << "\r\n";
                    s.send(ss.str());
                    (void)args;
                },
                "Print app describe"
            );
            wp_nodes->mountNode(info_node, func_node, "what");
        }
    }

    auto dump_node = wp_nodes->createDirNode("dump directory");
    wp_nodes->mountNode(wp_nodes->rootNode(), dump_node, "dump");
    {
        auto func_node = wp_nodes->createFuncNode(
            [this] (const Session &s, const Args &a) {
                Json js;
                if (util::string::IsEndWith(a[0], "apps")) {
                    module_->toJson(js);
                } else if (util::string::IsEndWith(a[0], "conf")){
                    js = *js_conf_;
                }
                auto json_str = js.dump(2);
                util::string::Replace(json_str, "\n", "\r\n");
                s.send(json_str);
                s.send("\r\n");
            },
            "Dump as JSON"
        );

        wp_nodes->mountNode(dump_node, func_node, "apps");
        wp_nodes->mountNode(dump_node, func_node, "conf");
    }
    {
        auto func_node = wp_nodes->createFuncNode(
            [this] (const Session &s, const Args &) {
                std::ostringstream oss;
                auto &args = *wp_args_;
                for (size_t i = 0; i < args.size(); ++i)
                    oss << '[' << i << "]:" << args.at(i) << "\r\n";
                oss << "\r\n";
                s.send(oss.str());
            },
            "Dump args"
        );

        wp_nodes->mountNode(dump_node, func_node, "args");
    }
}

}
}