/*
 *     .============.
 *    //  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 "log.h"
#include <iostream>
#include <sstream>
#include <tbox/base/json.hpp>
#include <tbox/base/catch_throw.h>
#include <tbox/terminal/session.h>
#include <tbox/terminal/helper.h>
#include <tbox/util/fs.h>
#include <tbox/util/json.h>
#include <tbox/util/string_to.h>

namespace tbox {
namespace main {

using namespace terminal;
using namespace std;

void Log::fillDefaultConfig(Json &cfg) const
{
    cfg["log"] = R"(
 {
  "stdout": {
    "enable": true,
    "enable_color": true,
    "levels": {"":7}
  }
}
)"_json;
}

bool Log::initialize(const char *proc_name, Context &ctx, const Json &cfg)
{
    shell_ = ctx.terminal();
    initShell();

    if (util::json::HasObjectField(cfg, "log")) {
        auto &js_log = cfg.at("log");

        int max_len = 0;
        if (util::json::GetField(js_log, "max_len", max_len) && max_len > 0) {
            LogSetMaxLength(static_cast<size_t>(max_len));
        }

        //! STDOUT
        if (util::json::HasObjectField(js_log, "stdout")) {
            installStdoutSink();
            initStdoutSinkByJson(js_log.at("stdout"));
        }
        //! SYSLOG
        if (util::json::HasObjectField(js_log, "syslog")) {
            installSyslogSink();
            initSyslogSinkByJson(js_log.at("syslog"));
        }

        //! FILELOG
        if (util::json::HasObjectField(js_log, "files")) {
            auto &js_files = js_log.at("files");
            for (auto &js_file : js_files.items()) {
                installFileSink(js_file.key());
                initFileSinkByJson(js_file.key(), js_file.value(), proc_name);
            }
        }
    }
    return true;
}

void Log::cleanup()
{
    for (auto &item: file_sinks_)
        uninstallFileSink(item.second, item.first);
    file_sinks_.clear();

    uninstallSyslogSink();
    uninstallStdoutSink();
}

bool Log::installStdoutSink()
{
    if (stdout_sink_ != nullptr)
        return false;

    stdout_sink_ = new StdoutSink;
    installShellForSink(stdout_sink_->sink, sink_node_, stdout_sink_->nodes, "stdout");

    return true;
}

bool Log::initStdoutSinkByJson(const Json &js)
{
    initSinkByJson(stdout_sink_->sink, js);
    return true;
}

bool Log::uninstallStdoutSink()
{
    if (stdout_sink_ == nullptr)
        return false;

    stdout_sink_->sink.disable();

    uninstallShellForSink(sink_node_, stdout_sink_->nodes, "stdout");

    CHECK_DELETE_RESET_OBJ(stdout_sink_);
    return true;
}

bool Log::installSyslogSink()
{
    if (syslog_sink_ != nullptr)
        return false;

    syslog_sink_ = new SyslogSink;
    installShellForSink(syslog_sink_->sink, sink_node_, syslog_sink_->nodes, "syslog");

    return true;
}

bool Log::initSyslogSinkByJson(const Json &js)
{
    initSinkByJson(syslog_sink_->sink, js);
    return true;
}

bool Log::uninstallSyslogSink()
{
    if (syslog_sink_ == nullptr)
        return false;

    syslog_sink_->sink.disable();
    syslog_sink_->sink.cleanup();

    uninstallShellForSink(sink_node_, syslog_sink_->nodes, "syslog");

    CHECK_DELETE_RESET_OBJ(syslog_sink_);
    return true;
}

bool Log::installFileSink(const std::string &name)
{
    //! 不能创建已有的通道名
    if (file_sinks_.find(name) != file_sinks_.end())
        return false;

    auto file_sink = new FileSink;
    installShellForFileSink(file_sink->sink, file_sink->nodes, name);
    file_sinks_.emplace(name, file_sink);
    return true;
}

bool Log::initFileSinkByJson(const std::string &name, const Json &js, const char *proc_name)
{
    auto iter = file_sinks_.find(name);
    if (iter == file_sinks_.end())
        return false;

    auto &sink = iter->second->sink;

    initSinkByJson(sink, js);

    std::string path;
    if (util::json::GetField(js, "path", path))
        sink.setFilePath(path);

    std::string prefix = util::fs::Basename(proc_name);
    util::json::GetField(js, "prefix", prefix);
    sink.setFilePrefix(prefix);

    bool enable_sync = false;
    if (util::json::GetField(js, "enable_sync", enable_sync))
        sink.setFileSyncEnable(enable_sync);

    unsigned int max_size = 0;
    if (util::json::GetField(js, "max_size", max_size))
        sink.setFileMaxSize(max_size * 1024);

    return true;
}

bool Log::uninstallFileSink(const std::string &name)
{
    auto iter = file_sinks_.find(name);
    if (iter == file_sinks_.end())
        return false;

    auto file_sink = iter->second;
    file_sinks_.erase(iter);

    uninstallFileSink(file_sink, name);
    return true;
}

bool Log::uninstallFileSink(FileSink *file_sink, const std::string &name)
{
    file_sink->sink.disable();
    file_sink->sink.cleanup();

    uninstallShellForFileSink(file_sink->nodes, name);

    CHECK_DELETE_OBJ(file_sink);
    return true;
}

void Log::initSinkByJson(log::Sink &sink, const Json &js)
{
    bool enable = false;
    if (util::json::GetField(js, "enable", enable)) {
        if (enable)
            sink.enable();
        else
            sink.disable();
    }

    bool enable_color = false;
    if (util::json::GetField(js, "enable_color", enable_color))
        sink.enableColor(enable_color);

    if (util::json::HasObjectField(js, "levels")) {
        auto &js_levels = js.at("levels");
        for (auto &item : js_levels.items())
            sink.setLevel(item.key(), item.value());
    }
}

void Log::initShell()
{
    auto log_node = terminal::AddDirNode(*shell_, shell_->rootNode(), "log", "This is log directory");
    sink_node_ = terminal::AddDirNode(*shell_, log_node, "sinks");

    {
        terminal::IntegerFuncNodeProfile profile;
        profile.set_func = \
            [] (int max_len) {
                if (max_len > 0) {
                    LogSetMaxLength(static_cast<size_t>(max_len));
                    return true;
                }
                return false;
            };
        profile.get_func = [] { return LogGetMaxLength(); };
        profile.usage = "Usage: max_len       # get max len, unit:byte\r\n"
                        "       max_len <len> # set max len, len>0\r\n";
        profile.help = "get or set log maxmum length";
        terminal::AddFuncNode(*shell_, log_node, "max_len", profile);
    }

    {
        auto func_node = shell_->createFuncNode(
            [this] (const Session &s, const Args &a) {
                std::ostringstream oss;
                bool print_usage = true;
                if (a.size() == 2) {
                    if (a[1] == "stdout") {
                        print_usage = false;
                        if (installStdoutSink())
                            oss << "done.\r\n";
                        else
                            oss << "fail, already exist.\r\n";

                    } else if (a[1] == "syslog") {
                        print_usage = false;
                        if (installSyslogSink())
                            oss << "done.\r\n";
                        else
                            oss << "fail, already exist.\r\n";
                    }

                } else if (a.size() == 3 && a[1] == "file") {
                    print_usage = false;
                    if (installFileSink(a[2]))
                        oss << "done\r\n";
                    else
                        oss << "fail, already exist.\r\n";
                }

                if (print_usage) {
                    oss << "Install log sink.\r\n"
                        << "Usage: " << a[0] << " stdout       # install stdout sink.\r\n"
                        << "       " << a[0] << " syslog       # install syslog sink.\r\n"
                        << "       " << a[0] << " file <name>  # install file sink by name.\r\n";
                }

                s.send(oss.str());
            },
            "install log sink"
        );
        shell_->mountNode(log_node, func_node, "add_sink");
    }

    {
        auto func_node = shell_->createFuncNode(
            [this] (const Session &s, const Args &a) {
                std::ostringstream oss;
                bool print_usage = true;
                if (a.size() == 2) {
                    if (a[1] == "stdout") {
                        print_usage = false;
                        if (uninstallStdoutSink())
                            oss << "done.\r\n";
                        else
                            oss << "fail, not exist.\r\n";

                    } else if (a[1] == "syslog") {
                        print_usage = false;
                        if (uninstallSyslogSink())
                            oss << "done.\r\n";
                        else
                            oss << "fail, not exist.\r\n";
                    }

                } else if (a.size() == 3 && a[1] == "file") {
                    print_usage = false;
                    if (uninstallFileSink(a[2]))
                        oss << "done.\r\n";
                    else
                        oss << "fail, not exist.\r\n";
                }

                if (print_usage) {
                    oss << "Uninstall log sink.\r\n"
                        << "Usage: " << a[0] << " stdout       # uninstall stdout sink.\r\n"
                        << "       " << a[0] << " syslog       # uninstall syslog sink.\r\n"
                        << "       " << a[0] << " file <name>  # uninstall file sink by name.\r\n";
                }

                s.send(oss.str());
            },
            "uninstall log sink"
        );
        shell_->mountNode(log_node, func_node, "del_sink");
    }
}

void Log::installShellForSink(log::Sink &sink, terminal::NodeToken parent_node, SinkShellNodes &nodes, const std::string &name)
{
    nodes.dir = terminal::AddDirNode(*shell_, parent_node, name);

    {
        terminal::BooleanFuncNodeProfile profile;
        profile.set_func = \
            [&sink] (bool is_enable) {
                if (is_enable)
                    sink.enable();
                else
                    sink.disable();
                return true;
            };
        profile.usage = "Usage: set_enable on|off\r\n";
        profile.help = "Enable or disable log sink";
        nodes.set_enable = terminal::AddFuncNode(*shell_, nodes.dir, "set_enable", profile);
    }

    {
        terminal::BooleanFuncNodeProfile profile;
        profile.set_func = \
            [&sink] (bool is_enable) {
                sink.enableColor(is_enable);
                return true;
            };
        profile.usage = "Usage: set_color_enable on|off\r\n";
        profile.help = "Enable or disable log color";
        nodes.set_color_enable = terminal::AddFuncNode(*shell_, nodes.dir, "set_color_enable", profile);
    }

    {
        auto func_node = shell_->createFuncNode(
            [&sink] (const Session &s, const Args &args) {
                std::ostringstream oss;
                bool print_usage = true;
                if (args.size() >= 3) {
                    do {
                        auto &module_id = args[1];
                        int level = 0;
                        if (!util::StringTo(args[2], level)) {
                            oss << "level must be number\r\n";
                            break;
                        }
                        if (level < 0 || level > TBOX_LOG_LEVEL_TRACE) {
                            oss << "level range: [0-" << TBOX_LOG_LEVEL_TRACE << "]\r\n";
                            break;
                        }

                        sink.setLevel(module_id, level);
                        oss << "done. level: " << level << "\r\n";
                        print_usage = false;

                    } while (false);
                }

                if (print_usage)
                    oss << "Usage: " << args[0] << " <module> <level:0-7>\r\n"
                       << "LEVEL\r\n"
                       << " 0: Fatal\r\n"
                       << " 1: Error\r\n"
                       << " 2: Warn\r\n"
                       << " 3: Notice\r\n"
                       << " 4: Important\r\n"
                       << " 5: Info\r\n"
                       << " 6: Debug\r\n"
                       << " 7: Trace\r\n"
                       ;

                s.send(oss.str());
            }
        , "set log level");
        shell_->mountNode(nodes.dir, func_node, "set_level");
        nodes.set_level = func_node;
    }

    {
        terminal::StringFuncNodeProfile profile;
        profile.set_func = \
            [&sink] (const std::string &module) {
                sink.unsetLevel(module);
                return true;
            };
        profile.usage = "Usage: unset_level <module>\r\n";
        profile.help = "Unset log level";
        nodes.unset_level = terminal::AddFuncNode(*shell_, nodes.dir, "unset_level", profile);
    }
}

void Log::uninstallShellForSink(terminal::NodeToken parent_node, SinkShellNodes &nodes, const std::string &name)
{
    shell_->deleteNode(nodes.dir);
    shell_->deleteNode(nodes.set_enable);
    shell_->deleteNode(nodes.set_color_enable);
    shell_->deleteNode(nodes.set_level);
    shell_->deleteNode(nodes.unset_level);

    shell_->umountNode(parent_node, name);
}

void Log::installShellForFileSink(log::AsyncFileSink &sink, FileSinkShellNodes &nodes, const std::string &name)
{
    //! 如果之前没有FileSink，则要创建并挂载files结点
    if (file_sinks_.empty())
        file_sink_node_ = terminal::AddDirNode(*shell_, sink_node_, "files");

    installShellForSink(sink, file_sink_node_, nodes, name);

    {
        terminal::StringFuncNodeProfile profile;
        profile.set_func = \
            [this, &sink] (const std::string &path) {
                sink.setFilePath(path);
                return true;
            };
        profile.usage = \
            "Usage: set_path <path>\r\n"
            "Exp  : set_path /var/log/\r\n";
        profile.help = "Set log file path";
        nodes.set_path = terminal::AddFuncNode(*shell_, nodes.dir, "set_path", profile);
    }

    {
        terminal::StringFuncNodeProfile profile;
        profile.set_func = \
            [this, &sink] (const std::string &prefix) {
                sink.setFilePrefix(prefix);
                return true;
            };
        profile.usage = "Usage: set_prefix <prefix>\r\n";
        profile.help = "Set log file prefix";
        nodes.set_prefix = terminal::AddFuncNode(*shell_, nodes.dir, "set_prefix", profile);
    }

    {
        terminal::BooleanFuncNodeProfile profile;
        profile.set_func = \
            [this, &sink] (bool is_enable) {
                sink.setFileSyncEnable(is_enable);
                return true;
            };
        profile.usage = "Usage: set_sync_enable on|off\r\n";
        profile.help = "Enable or disable file sync";
        nodes.set_sync_enable = terminal::AddFuncNode(*shell_, nodes.dir, "set_sync_enable", profile);
    }

    {
        terminal::IntegerFuncNodeProfile profile;
        profile.set_func = \
            [this, &sink] (int max_size) {
                sink.setFileMaxSize(max_size * 1024);
                return true;
            };
        profile.min_value = 1;
        profile.usage = \
            "Usage: set_max_size <size>  # Unit KB, >=1\r\n"
            "Exp  : set_max_size 1024\r\n";
        profile.help = "Set log file max size";
        nodes.set_max_size = terminal::AddFuncNode(*shell_, nodes.dir, "set_max_size", profile);
    }
}

void Log::uninstallShellForFileSink(FileSinkShellNodes &nodes, const std::string &name)
{
    shell_->deleteNode(nodes.set_path);
    shell_->deleteNode(nodes.set_prefix);
    shell_->deleteNode(nodes.set_sync_enable);
    shell_->deleteNode(nodes.set_max_size);

    uninstallShellForSink(file_sink_node_, nodes, name);

    if (file_sinks_.empty()) {
        shell_->umountNode(sink_node_, "files");
        shell_->deleteNode(file_sink_node_);
        file_sink_node_.reset();
    }
}

}
}