// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//   http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied.  See the License for the
// specific language governing permissions and limitations
// under the License.

#include "logging.h"

#include <bthread/bthread.h>
#include <bthread/types.h>
#include <glog/logging.h>
#include <glog/vlog_is_on.h>

#include <iomanip>
#include <iostream>
#include <mutex>

#include "config.h"

namespace doris::cloud {

static butil::LinkedList<AnnotateTag>* get_annotate_tag_list() {
    static std::once_flag log_annotated_tags_key_once;
    static bthread_key_t log_annotated_tags_key;
    std::call_once(
            log_annotated_tags_key_once,
            +[](bthread_key_t* key) {
                bthread_key_create(
                        key, +[](void* value) {
                            delete reinterpret_cast<butil::LinkedList<AnnotateTag>*>(value);
                        });
            },
            &log_annotated_tags_key);

    auto* tag_list = reinterpret_cast<butil::LinkedList<AnnotateTag>*>(
            bthread_getspecific(log_annotated_tags_key));
    if (!tag_list) {
        tag_list = new butil::LinkedList<AnnotateTag>();
        bthread_setspecific(log_annotated_tags_key, tag_list);
    }
    return tag_list;
}

AnnotateTag::AnnotateTag(default_tag_t, std::string_view key, std::string value)
        : key_(key), value_(std::move(value)) {
    get_annotate_tag_list()->Append(this);
}

AnnotateTag::AnnotateTag(std::string_view key, std::string_view value)
        : AnnotateTag(default_tag, key, fmt::format("\"{}\"", value)) {}

AnnotateTag::~AnnotateTag() {
    RemoveFromList();
}

void AnnotateTag::format_tag_list(std::ostream& stream) {
    butil::LinkedList<AnnotateTag>* list = get_annotate_tag_list();
    butil::LinkNode<AnnotateTag>* head = list->head();
    const butil::LinkNode<AnnotateTag>* end = list->end();
    for (; head != end; head = head->next()) {
        stream << ' ' << head->value()->key_ << '=' << head->value()->value_;
    }
}

void custom_prefix(std::ostream& s, const google::LogMessageInfo& l, void*) {
    // Add prefix "RuntimeLogger ".
    s << "RuntimeLogger ";
    // Same as in fe.log
    // The following is same as default log format. eg:
    // I20240605 15:25:15.677153 1763151 meta_service_txn.cpp:481] msg...
    s << l.severity[0];
    s << std::setw(4) << 1900 + l.time.year();
    s << std::setw(2) << 1 + l.time.month();
    s << std::setw(2) << l.time.day();
    s << ' ';
    s << std::setw(2) << l.time.hour() << ':';
    s << std::setw(2) << l.time.min() << ':';
    s << std::setw(2) << l.time.sec() << ".";
    s << std::setw(6) << l.time.usec();
    s << ' ';
    s << std::setfill(' ') << std::setw(5);
    s << l.thread_id << std::setfill('0');
    s << ' ';
    s << l.filename << ':' << l.line_number << "]";
}

// Implement the custom log format for stdout output in K8S environment
// Format: I20240605 15:25:15.677153 1763151 meta_service_txn.cpp:481] msg...
struct StdoutLogSink : google::LogSink {
    void send(google::LogSeverity severity, const char* /*full_filename*/,
              const char* base_filename, int line, const google::LogMessageTime& time,
              const char* message, std::size_t message_len) override {
        // Convert log severity to corresponding character (I/W/E/F)
        char severity_char;
        switch (severity) {
        case google::GLOG_INFO:
            severity_char = 'I';
            break;
        case google::GLOG_WARNING:
            severity_char = 'W';
            break;
        case google::GLOG_ERROR:
            severity_char = 'E';
            break;
        case google::GLOG_FATAL:
            severity_char = 'F';
            break;
        default:
            severity_char = '?';
            break;
        }

        // Set output formatting flags
        std::cout << std::setfill('0');

        // 1. Log severity (I/W/E/F)
        std::cout << severity_char;

        // 2. Date (YYYYMMDD)
        // Note: tm_year is years since 1900, tm_mon is 0-based (0-11)
        std::cout << std::setw(4) << (time.year() + 1900) << std::setw(2) << std::setfill('0')
                  << (time.month() + 1) << std::setw(2) << std::setfill('0') << time.day();

        // 3. Time (HH:MM:SS.ffffff)
        std::cout << " " << std::setw(2) << std::setfill('0') << time.hour() << ":" << std::setw(2)
                  << std::setfill('0') << time.min() << ":" << std::setw(2) << std::setfill('0')
                  << time.sec() << "." << std::setw(6) << std::setfill('0') << time.usec();

        // 4. Thread ID
        std::cout << " " << std::setfill(' ') << std::setw(5) << getpid() << std::setfill('0');

        // 5. Filename and line number
        std::cout << " " << base_filename << ":" << line << "] ";

        // 6. Log message
        std::cout.write(message, message_len);

        // Add newline and flush
        std::cout << std::endl;
    }
};

static StdoutLogSink stdout_log_sink;

/**
 * @param basename the basename of log file
 * @return true for success
 */
bool init_glog(const char* basename) {
    static std::mutex mtx;
    static bool inited = false;
    std::lock_guard<std::mutex> logging_lock(mtx);
    if (inited) return true;

    bool log_to_console = (getenv("DORIS_LOG_TO_STDERR") != nullptr);
    if (log_to_console) {
        if (config::enable_file_logger) {
            // will output log to log file and output log to stdout
            google::AddLogSink(&stdout_log_sink);
        } else {
            // enable_file_logger is false, will only output log to stdout
            // Not output to stderr because doris_cloud.out will output log to stderr
            FLAGS_logtostdout = true;
        }
    } else {
        FLAGS_alsologtostderr = false;
    }

    // Don't log to stderr except fatal level
    // so fatal log can output to doris_cloud.out .
    FLAGS_stderrthreshold = google::FATAL;

    // Set glog log dir
    FLAGS_log_dir = config::log_dir;
    // Buffer log messages for at most this many seconds
    FLAGS_logbufsecs = 1;
    // Set log roll mode
    // Candidates: day, hour, size
    FLAGS_log_split_method = "size";
    // Sets the maximum log file size (in MB).
    FLAGS_max_log_size = config::log_size_mb;
    // Set roll num
    FLAGS_log_filenum_quota = config::log_filenum_quota;

#ifdef GLOG_HAS_WARN_LOG_FILENUM_QUOTA
    // Set warn log roll num
    FLAGS_warn_log_filenum_quota = config::warn_log_filenum_quota;
#endif

    // clang-format off
    // set log level
    std::string& loglevel = config::log_level;
    // Can be 0 1 2 3 ... the larger the higher level for logging,
    // corrensponding to INFO WARNING ERROR FATAL
    // const int GLOG_INFO = 0, GLOG_WARNING = 1, GLOG_ERROR = 2, GLOG_FATAL = 3, NUM_SEVERITIES = 4;
    auto tolower = [](std::string s) { for (auto& i : s) i |= 0x20; return s; };
    FLAGS_minloglevel = tolower(loglevel) == "info"  ? 0
                      : tolower(loglevel) == "warn"  ? 1
                      : tolower(loglevel) == "error" ? 2
                      : tolower(loglevel) == "fatal" ? 3
                      :                                0; // Default INFO
    // clang-format on

    // Log messages at a level <= this flag are buffered.
    // Log messages at a higher level are flushed immediately.
    FLAGS_logbuflevel = config::log_immediate_flush ? -1 : 0;

    // Set verbose modules
    FLAGS_v = -1;
    for (auto& i : config::log_verbose_modules) {
        if (i.empty()) continue;
        google::SetVLOGLevel(i.c_str(), config::log_verbose_level);
    }
    if (log_to_console) {
        // Only add prefix if log output to stderr
        google::InitGoogleLogging(basename, &custom_prefix);
    } else {
        google::InitGoogleLogging(basename);
    }
    inited = true;
    return true;
}

} // namespace doris::cloud