#include "vp_logger.h"

namespace vp_utils {
        
    vp_logger::vp_logger(/* args */)
    {
    }
    
    vp_logger::~vp_logger() {
        die();
        if (log_writer_th.joinable()) {
            log_writer_th.join();
        }
    }

    void vp_logger::die() {
        alive = false;
        std::lock_guard<std::mutex> guard(log_cache_mutex);
        log_cache.push("die");
        log_cache_semaphore.signal();
    }

    void vp_logger::init() {
        inited = true;

        // initialize file writer
        file_writer.init(log_dir, log_file_name_template);

        #ifdef VP_WITH_KAFKA
        // initialize kafka writer
        auto servers_and_topic = vp_utils::string_split(kafka_servers_and_topic, '/');
        assert(servers_and_topic.size() == 2);
        kafka_writer.init(servers_and_topic[0], servers_and_topic[1]);
        #endif

        // run thread
        auto t = std::thread(&vp_logger::log_write_run, this); 
        log_writer_th = std::move(t);
    }

    void vp_logger::log(vp_log_level level, const std::string& message, const char* code_file, int code_line) {
        // make sure logger is initialized
        if (!inited) {
            throw "vp_logger is not initialized yet!";
        }
        
        // level filter
        if (level > log_level) {
            return;
        }
        
        // keywords filter for debug level
        if (level == vp_log_level::DEBUG && keywords_for_debug_log.size() != 0) {
            bool filterd = true;
            for(auto& keywords: keywords_for_debug_log) {
                if (message.find(keywords) != std::string::npos) {
                    filterd = false;
                    break;
                }
            }
            if (filterd) {
                return;
            }
        }
        
        /* create log */
        std::string new_log = "";
        // 100% true for log time
        if (include_time) {
            new_log += vp_utils::time_format(NOW, log_time_templete);
        }

        // log level
        if (include_level) {
            new_log += "[" + log_level_names.at(level) + "]";
        }

        // thread id
        if (include_thread_id) {
            auto id = std::this_thread::get_id();
            std::stringstream ss;
            ss << std::hex << id;  // to hex
            auto thread_id = ss.str(); 
            new_log += "[" + thread_id + "]";
        }
        
        // code location
        if (include_code_location) {
            new_log += "[" + std::string(code_file) + ":" + std::to_string(code_line) + "]";
        }

        new_log += " " + message;

        /* write to cache */
        // min lock range
        std::lock_guard<std::mutex> guard(log_cache_mutex);
        log_cache.push(new_log);
        // notify
        log_cache_semaphore.signal();
    }

    void vp_logger::log_write_run() {
        bool log_thres_warned = false;
        /* below code runs in single thread */
        while (inited && alive) {
            // wait for data
            log_cache_semaphore.wait();
            auto log = log_cache.front();
            log_cache.pop();

            if (log == "die") {
                continue;
            }
            
            /* watch the log cache size */
            auto log_cache_size = 0;
            {
                // min lock range
                std::lock_guard<std::mutex> guard(log_cache_mutex);
                log_cache_size = log_cache.size();
            }
            if (!log_thres_warned && log_cache_size > log_cache_warn_threshold) {
                VP_WARN(vp_utils::string_format("[logger] log cache size is exceeding threshold! cache size is: [%d], threshold is: [%d]", log_cache_size, log_cache_warn_threshold));
                log_thres_warned = true;  // warn 1 time
            }
            if (log_cache_size <= log_cache_warn_threshold) {
                log_thres_warned = false;
            }
            
            /* write to devices */
            if (log_to_console) {
                write_to_console(log);
            }
            
            if (log_to_file) {
                write_to_file(log);
            }

            if (log_to_kafka) {
                write_to_kafka(log);
            }
        }
    }

    void vp_logger::write_to_console(const std::string& log) {
        std::cout << log << std::endl;
    }

    void vp_logger::write_to_file(const std::string& log) {
        // file_writer.write(log);
        file_writer << log;
    }

    void vp_logger::write_to_kafka(const std::string& log) {
        #ifdef VP_WITH_KAFKA
        // kafka_writer.write(log);
        kafka_writer << log;
        #endif
    }
}