/***
      __   __  _  _  __     __    ___
     / _\ (  )( \/ )(  )   /  \  / __)
    /    \ )(  )  ( / (_/\(  O )( (_ \
    \_/\_/(__)(_/\_)\____/ \__/  \___/
    version 1.4.0
    https://github.com/badaix/aixlog

    This file is part of aixlog
    Copyright (C) 2017-2020 Johannes Pohl

    This software may be modified and distributed under the terms
    of the MIT license.  See the LICENSE file for details.
***/

/// inspired by "eater":
/// https://stackoverflow.com/questions/2638654/redirect-c-stdclog-to-syslog-on-unix

#ifndef AIX_LOG_HPP
#define AIX_LOG_HPP

#ifndef _WIN32
#define HAS_SYSLOG_ 1
#endif

#ifdef __APPLE__
#ifdef __MAC_OS_X_VERSION_MAX_ALLOWED
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1012
#define HAS_APPLE_UNIFIED_LOG_ 1
#endif
#endif
#endif

#include <algorithm>
#include <cctype>
#include <chrono>
#include <cstdio>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <mutex>
#include <sstream>
#include <thread>
#include <vector>

#ifdef __ANDROID__
#include <android/log.h>
#endif

#ifdef _WIN32
#include <Windows.h>
// ERROR macro is defined in Windows header
// To avoid conflict between these macro and declaration of ERROR / DEBUG in SEVERITY enum
// We save macro and undef it
#pragma push_macro("ERROR")
#pragma push_macro("DEBUG")
#undef ERROR
#undef DEBUG
#endif

#ifdef HAS_APPLE_UNIFIED_LOG_
#include <os/log.h>
#endif

#ifdef HAS_SYSLOG_
#include <syslog.h>
#endif

#ifdef __ANDROID__
// fix for bug "Android NDK __func__ definition is inconsistent with glibc and C++99"
// https://bugs.chromium.org/p/chromium/issues/detail?id=631489
#ifdef __GNUC__
#define AIXLOG_INTERNAL__FUNC __FUNCTION__
#else
#define AIXLOG_INTERNAL__FUNC __func__
#endif
#else
#define AIXLOG_INTERNAL__FUNC __func__
#endif

/// Internal helper macros (exposed, but shouldn't be used directly)
#define AIXLOG_INTERNAL__LOG_SEVERITY(SEVERITY_) std::clog << static_cast<AixLog::Severity>(SEVERITY_) << TAG()
#define AIXLOG_INTERNAL__LOG_SEVERITY_TAG(SEVERITY_, TAG_) std::clog << static_cast<AixLog::Severity>(SEVERITY_) << TAG(TAG_)

#define AIXLOG_INTERNAL__ONE_COLOR(FG_) AixLog::Color::FG_
#define AIXLOG_INTERNAL__TWO_COLOR(FG_, BG_) AixLog::TextColor(AixLog::Color::FG_, AixLog::Color::BG_)

// https://stackoverflow.com/questions/3046889/optional-parameters-with-c-macros
#define AIXLOG_INTERNAL__VAR_PARM(PARAM1_, PARAM2_, FUNC_, ...) FUNC_
#define AIXLOG_INTERNAL__LOG_MACRO_CHOOSER(...) AIXLOG_INTERNAL__VAR_PARM(__VA_ARGS__, AIXLOG_INTERNAL__LOG_SEVERITY_TAG, AIXLOG_INTERNAL__LOG_SEVERITY, )
#define AIXLOG_INTERNAL__COLOR_MACRO_CHOOSER(...) AIXLOG_INTERNAL__VAR_PARM(__VA_ARGS__, AIXLOG_INTERNAL__TWO_COLOR, AIXLOG_INTERNAL__ONE_COLOR, )

/// External logger macros
// usage: LOG(SEVERITY) or LOG(SEVERITY, TAG)
// e.g.: LOG(NOTICE) or LOG(NOTICE, "my tag")
#ifndef WIN32
#define LOG(...) AIXLOG_INTERNAL__LOG_MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__) << TIMESTAMP << FUNC
#endif

// usage: COLOR(TEXT_COLOR, BACKGROUND_COLOR) or COLOR(TEXT_COLOR)
// e.g.: COLOR(yellow, blue) or COLOR(red)
#define COLOR(...) AIXLOG_INTERNAL__COLOR_MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__)

#define FUNC AixLog::Function(AIXLOG_INTERNAL__FUNC, __FILE__, __LINE__)
#define TAG AixLog::Tag
#define COND AixLog::Conditional
#define TIMESTAMP AixLog::Timestamp(std::chrono::system_clock::now())


// stijnvdb: sorry! :) LOG(SEV, "tag") was not working for Windows and I couldn't figure out how to fix it for windows without potentially breaking everything
// else...
// https://stackoverflow.com/questions/3046889/optional-parameters-with-c-macros (Jason Deng)
#ifdef WIN32
#define LOG_2(severity, tag) AIXLOG_INTERNAL__LOG_SEVERITY_TAG(severity, tag)
#define LOG_1(severity) AIXLOG_INTERNAL__LOG_SEVERITY(severity)
#define LOG_0() LOG_1(0)

#define FUNC_CHOOSER(_f1, _f2, _f3, ...) _f3
#define FUNC_RECOMPOSER(argsWithParentheses) FUNC_CHOOSER argsWithParentheses
#define CHOOSE_FROM_ARG_COUNT(...) FUNC_RECOMPOSER((__VA_ARGS__, LOG_2, LOG_1, FUNC_, ...))
#define MACRO_CHOOSER(...) CHOOSE_FROM_ARG_COUNT(__VA_ARGS__())
#define LOG(...) MACRO_CHOOSER(__VA_ARGS__)(__VA_ARGS__) << TIMESTAMP << FUNC
#endif

/**
 * @brief
 * Severity of the log message
 */
enum SEVERITY
{
    TRACE = 0,
    DEBUG = 1,
    INFO = 2,
    NOTICE = 3,
    WARNING = 4,
    ERROR = 5,
    FATAL = 6
};

namespace AixLog
{

/**
 * @brief
 * Severity of the log message
 *
 * Mandatory parameter for the LOG macro
 */
enum class Severity : std::int8_t
{
    // Mapping table from AixLog to other loggers. Boost is just for information.
    // https://chromium.googlesource.com/chromium/mini_chromium/+/master/base/logging.cc
    //
    // Aixlog      Boost       Syslog      Android     macOS       EventLog      Syslog Desc
    //
    // trace       trace       DEBUG       VERBOSE     DEBUG       INFORMATION
    // debug       debug       DEBUG       DEBUG       DEBUG       INFORMATION   debug-level message
    // info        info        INFO        INFO        INFO        SUCCESS       informational message
    // notice                  NOTICE      INFO        INFO        SUCCESS       normal, but significant, condition
    // warning     warning     WARNING     WARN        DEFAULT     WARNING       warning conditions
    // error       error       ERROR       ERROR       ERROR       ERROR         error conditions
    // fatal       fatal       CRIT        FATAL       FAULT       ERROR         critical conditions
    //                         ALERT                                             action must be taken immediately
    //                         EMERG                                             system is unusable

    trace = SEVERITY::TRACE,
    debug = SEVERITY::DEBUG,
    info = SEVERITY::INFO,
    notice = SEVERITY::NOTICE,
    warning = SEVERITY::WARNING,
    error = SEVERITY::ERROR,
    fatal = SEVERITY::FATAL
};


static Severity to_severity(std::string severity, Severity def = Severity::info)
{
    std::transform(severity.begin(), severity.end(), severity.begin(), [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
    if (severity == "trace")
        return Severity::trace;
    else if (severity == "debug")
        return Severity::debug;
    else if (severity == "info")
        return Severity::info;
    else if (severity == "notice")
        return Severity::notice;
    else if (severity == "warning")
        return Severity::warning;
    else if (severity == "error")
        return Severity::error;
    else if (severity == "fatal")
        return Severity::fatal;
    else
        return def;
}


static std::string to_string(Severity logSeverity)
{
    switch (logSeverity)
    {
        case Severity::trace:
            return "Trace";
        case Severity::debug:
            return "Debug";
        case Severity::info:
            return "Info";
        case Severity::notice:
            return "Notice";
        case Severity::warning:
            return "Warn";
        case Severity::error:
            return "Error";
        case Severity::fatal:
            return "Fatal";
        default:
            std::stringstream ss;
            ss << static_cast<int>(logSeverity);
            return ss.str();
    }
}

/**
 * @brief
 * Color constants used for console colors
 */
enum class Color
{
    none = 0,
    NONE = 0,
    black = 1,
    BLACK = 1,
    red = 2,
    RED = 2,
    green = 3,
    GREEN = 3,
    yellow = 4,
    YELLOW = 4,
    blue = 5,
    BLUE = 5,
    magenta = 6,
    MAGENTA = 6,
    cyan = 7,
    CYAN = 7,
    white = 8,
    WHITE = 8
};

/**
 * @brief
 * Encapsulation of foreground and background color
 */
struct TextColor
{
    TextColor(Color foreground = Color::none, Color background = Color::none) : foreground(foreground), background(background)
    {
    }

    Color foreground;
    Color background;
};

/**
 * @brief
 * For Conditional logging of a log line
 */
struct Conditional
{
    Conditional() : Conditional(true)
    {
    }

    Conditional(bool value) : is_true_(value)
    {
    }

    void set(bool value)
    {
        is_true_ = value;
    }

    bool is_true() const
    {
        return is_true_;
    }

private:
    bool is_true_;
};

/**
 * @brief
 * Timestamp of a log line
 *
 * to_string will convert the time stamp into a string, using the strftime syntax
 */
struct Timestamp
{
    using time_point_sys_clock = std::chrono::time_point<std::chrono::system_clock>;

    Timestamp(std::nullptr_t) : is_null_(true)
    {
    }

    Timestamp() : Timestamp(nullptr)
    {
    }

    Timestamp(const time_point_sys_clock& time_point) : time_point(time_point), is_null_(false)
    {
    }

    Timestamp(time_point_sys_clock&& time_point) : time_point(std::move(time_point)), is_null_(false)
    {
    }

    virtual ~Timestamp() = default;

    explicit operator bool() const
    {
        return !is_null_;
    }

    /// strftime format + proprietary "#ms" for milliseconds
    std::string to_string(const std::string& format = "%Y-%m-%d %H-%M-%S.#ms") const
    {
        std::time_t now_c = std::chrono::system_clock::to_time_t(time_point);
        struct ::tm now_tm = localtime_xp(now_c);
        char buffer[256];
        strftime(buffer, sizeof buffer, format.c_str(), &now_tm);
        std::string result(buffer);
        size_t pos = result.find("#ms");
        if (pos != std::string::npos)
        {
            int ms_part = std::chrono::time_point_cast<std::chrono::milliseconds>(time_point).time_since_epoch().count() % 1000;
            char ms_str[4];
            if (snprintf(ms_str, 4, "%03d", ms_part) >= 0)
                result.replace(pos, 3, ms_str);
        }
        return result;
    }

    time_point_sys_clock time_point;

private:
    bool is_null_;

    inline std::tm localtime_xp(std::time_t timer) const
    {
        std::tm bt;
#if defined(__unix__)
        localtime_r(&timer, &bt);
#elif defined(_MSC_VER)
        localtime_s(&bt, &timer);
#else
        static std::mutex mtx;
        std::lock_guard<std::mutex> lock(mtx);
        bt = *std::localtime(&timer);
#endif
        return bt;
    }
};

/**
 * @brief
 * Tag (string) for log line
 */
struct Tag
{
    Tag(std::nullptr_t) : text(""), is_null_(true)
    {
    }

    Tag() : Tag(nullptr)
    {
    }

    Tag(const char* text) : text(text), is_null_(false)
    {
    }

    Tag(const std::string& text) : text(text), is_null_(false)
    {
    }

    Tag(std::string&& text) : text(std::move(text)), is_null_(false)
    {
    }

    virtual ~Tag() = default;

    explicit operator bool() const
    {
        return !is_null_;
    }

    bool operator<(const Tag& other) const
    {
        return (text < other.text);
    }

    std::string text;

private:
    bool is_null_;
};

/**
 * @brief
 * Capture function, file and line number of the log line
 */
struct Function
{
    Function(const std::string& name, const std::string& file, size_t line) : name(name), file(file), line(line), is_null_(false)
    {
    }

    Function(std::string&& name, std::string&& file, size_t line) : name(std::move(name)), file(std::move(file)), line(line), is_null_(false)
    {
    }

    Function(std::nullptr_t) : name(""), file(""), line(0), is_null_(true)
    {
    }

    Function() : Function(nullptr)
    {
    }

    virtual ~Function() = default;

    explicit operator bool() const
    {
        return !is_null_;
    }

    std::string name;
    std::string file;
    size_t line;

private:
    bool is_null_;
};

/**
 * @brief
 * Collection of a log line's meta data
 */
struct Metadata
{
    Metadata() : severity(Severity::trace), tag(nullptr), function(nullptr), timestamp(nullptr)
    {
    }

    Severity severity;
    Tag tag;
    Function function;
    Timestamp timestamp;
};


class Filter
{
public:
    Filter()
    {
    }

    Filter(Severity severity)
    {
        add_filter(severity);
    }

    bool match(const Metadata& metadata) const
    {
        if (tag_filter_.empty())
            return true;

        auto iter = tag_filter_.find(metadata.tag);
        if (iter != tag_filter_.end())
            return (metadata.severity >= iter->second);

        iter = tag_filter_.find("*");
        if (iter != tag_filter_.end())
            return (metadata.severity >= iter->second);

        return false;
    }

    void add_filter(const Tag& tag, Severity severity)
    {
        tag_filter_[tag] = severity;
    }

    void add_filter(Severity severity)
    {
        tag_filter_["*"] = severity;
    }

    void add_filter(const std::string& filter)
    {
        auto pos = filter.find(":");
        if (pos != std::string::npos)
            add_filter(filter.substr(0, pos), to_severity(filter.substr(pos + 1)));
        else
            add_filter(to_severity(filter));
    }

private:
    std::map<Tag, Severity> tag_filter_;
};


/**
 * @brief
 * Abstract log sink
 *
 * All log sinks must inherit from this Sink
 */
struct Sink
{
    Sink(const Filter& filter) : filter(filter)
    {
    }

    virtual ~Sink() = default;

    virtual void log(const Metadata& metadata, const std::string& message) = 0;

    Filter filter;
};

/// ostream operators << for the meta data structs
static std::ostream& operator<<(std::ostream& os, const Severity& log_severity);
static std::ostream& operator<<(std::ostream& os, const Timestamp& timestamp);
static std::ostream& operator<<(std::ostream& os, const Tag& tag);
static std::ostream& operator<<(std::ostream& os, const Function& function);
static std::ostream& operator<<(std::ostream& os, const Conditional& conditional);
static std::ostream& operator<<(std::ostream& os, const Color& color);
static std::ostream& operator<<(std::ostream& os, const TextColor& text_color);

using log_sink_ptr = std::shared_ptr<Sink>;

/**
 * @brief
 * Main Logger class with "Log::init"
 *
 * Don't use it directly, but call once "Log::init" with your log sink instances.
 * The Log class will simply redirect clog to itself (as a streambuf) and
 * forward whatever went to clog to the log sink instances
 */
class Log : public std::basic_streambuf<char, std::char_traits<char>>
{
public:
    static Log& instance()
    {
        static Log instance_;
        return instance_;
    }

    /// Without "init" every LOG(X) will simply go to clog
    static void init(const std::vector<log_sink_ptr> log_sinks = {})
    {
        Log::instance().log_sinks_.clear();

        for (const auto& sink : log_sinks)
            Log::instance().add_logsink(sink);
    }

    template <typename T, typename... Ts>
    static std::shared_ptr<T> init(Ts&&... params)
    {
        std::shared_ptr<T> sink = Log::instance().add_logsink<T>(std::forward<Ts>(params)...);
        init({sink});
        return sink;
    }

    template <typename T, typename... Ts>
    std::shared_ptr<T> add_logsink(Ts&&... params)
    {
        std::lock_guard<std::recursive_mutex> lock(mutex_);
        static_assert(std::is_base_of<Sink, typename std::decay<T>::type>::value, "type T must be a Sink");
        std::shared_ptr<T> sink = std::make_shared<T>(std::forward<Ts>(params)...);
        log_sinks_.push_back(sink);
        return sink;
    }

    void add_logsink(const log_sink_ptr& sink)
    {
        std::lock_guard<std::recursive_mutex> lock(mutex_);
        log_sinks_.push_back(sink);
    }

    void remove_logsink(const log_sink_ptr& sink)
    {
        std::lock_guard<std::recursive_mutex> lock(mutex_);
        log_sinks_.erase(std::remove(log_sinks_.begin(), log_sinks_.end(), sink), log_sinks_.end());
    }

protected:
    Log() noexcept : last_buffer_(nullptr)
    {
        std::clog.rdbuf(this);
        std::clog << Severity() << Tag() << Function() << Conditional() << AixLog::Color::NONE << std::flush;
    }

    virtual ~Log()
    {
        sync();
    }

    int sync() override
    {
        std::lock_guard<std::recursive_mutex> lock(mutex_);
        if (!get_stream().str().empty())
        {
            if (conditional_.is_true())
            {
                for (const auto& sink : log_sinks_)
                {
                    if (sink->filter.match(metadata_))
                        sink->log(metadata_, get_stream().str());
                }
            }
            get_stream().str("");
            get_stream().clear();
        }

        return 0;
    }

    int overflow(int c) override
    {
        std::lock_guard<std::recursive_mutex> lock(mutex_);
        if (c != EOF)
        {
            if (c == '\n')
                sync();
            else
                get_stream() << static_cast<char>(c);
        }
        else
        {
            sync();
        }
        return c;
    }

private:
    friend std::ostream& operator<<(std::ostream& os, const Severity& log_severity);
    friend std::ostream& operator<<(std::ostream& os, const Timestamp& timestamp);
    friend std::ostream& operator<<(std::ostream& os, const Tag& tag);
    friend std::ostream& operator<<(std::ostream& os, const Function& function);
    friend std::ostream& operator<<(std::ostream& os, const Conditional& conditional);

    std::stringstream& get_stream()
    {
        auto id = std::this_thread::get_id();
        if ((last_buffer_ == nullptr) || (last_id_ != id))
        {
            last_id_ = id;
            last_buffer_ = &(buffer_[id]);
        }
        return *last_buffer_;
    }

    std::map<std::thread::id, std::stringstream> buffer_;
    std::thread::id last_id_;
    std::stringstream* last_buffer_ = nullptr;
    Metadata metadata_;
    Conditional conditional_;
    std::vector<log_sink_ptr> log_sinks_;
    std::recursive_mutex mutex_;
};

/**
 * @brief
 * Null log sink
 *
 * Discards all log messages
 */
struct SinkNull : public Sink
{
    SinkNull() : Sink(Filter())
    {
    }

    void log(const Metadata& /*metadata*/, const std::string& /*message*/) override
    {
    }
};


/**
 * @brief
 * Abstract log sink with support for formatting log message
 *
 * "format" in the c'tor defines a log pattern.
 * For every log message, these placeholders will be substituded:
 * - strftime syntax is used to format the logging time stamp (%Y, %m, %d, ...)
 * - #ms: milliseconds part of the logging time stamp with leading zeros
 * - #severity: log severity
 * - #tag_func: the log tag. If empty, the function
 * - #tag: the log tag
 * - #function: the function
 * - #message: the log message
 */
struct SinkFormat : public Sink
{
    SinkFormat(const Filter& filter, const std::string& format) : Sink(filter), format_(format)
    {
    }

    virtual void set_format(const std::string& format)
    {
        format_ = format;
    }

    void log(const Metadata& metadata, const std::string& message) override = 0;

protected:
    virtual void do_log(std::ostream& stream, const Metadata& metadata, const std::string& message) const
    {
        std::string result = format_;
        if (metadata.timestamp)
            result = metadata.timestamp.to_string(result);

        size_t pos = result.find("#severity");
        if (pos != std::string::npos)
            result.replace(pos, 9, to_string(metadata.severity));

        pos = result.find("#color_severity");
        if (pos != std::string::npos)
        {
            std::stringstream ss;
            ss << TextColor(Color::RED) << to_string(metadata.severity) << TextColor(Color::NONE);
            result.replace(pos, 15, ss.str());
        }

        pos = result.find("#tag_func");
        if (pos != std::string::npos)
            result.replace(pos, 9, metadata.tag ? metadata.tag.text : (metadata.function ? metadata.function.name : "log"));

        pos = result.find("#tag");
        if (pos != std::string::npos)
            result.replace(pos, 4, metadata.tag ? metadata.tag.text : "");

        pos = result.find("#function");
        if (pos != std::string::npos)
            result.replace(pos, 9, metadata.function ? metadata.function.name : "");

        pos = result.find("#message");
        if (pos != std::string::npos)
        {
            result.replace(pos, 8, message);
            stream << result << std::endl;
        }
        else
        {
            if (result.empty() || (result.back() == ' '))
                stream << result << message << std::endl;
            else
                stream << result << " " << message << std::endl;
        }
    }

    std::string format_;
};

/**
 * @brief
 * Formatted logging to cout
 */
struct SinkCout : public SinkFormat
{
    SinkCout(const Filter& filter, const std::string& format = "%Y-%m-%d %H-%M-%S.#ms [#severity] (#tag_func)") : SinkFormat(filter, format)
    {
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        do_log(std::cout, metadata, message);
    }
};

/**
 * @brief
 * Formatted logging to cerr
 */
struct SinkCerr : public SinkFormat
{
    SinkCerr(const Filter& filter, const std::string& format = "%Y-%m-%d %H-%M-%S.#ms [#severity] (#tag_func)") : SinkFormat(filter, format)
    {
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        do_log(std::cerr, metadata, message);
    }
};

/**
 * @brief
 * Formatted logging to file
 */
struct SinkFile : public SinkFormat
{
    SinkFile(const Filter& filter, const std::string& filename, const std::string& format = "%Y-%m-%d %H-%M-%S.#ms [#severity] (#tag_func)")
        : SinkFormat(filter, format)
    {
        ofs.open(filename.c_str(), std::ofstream::out | std::ofstream::trunc);
    }

    ~SinkFile() override
    {
        ofs.close();
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        do_log(ofs, metadata, message);
    }

protected:
    mutable std::ofstream ofs;
};

#ifdef _WIN32
/**
 * @brief
 * Windows: Logging to OutputDebugString
 *
 * Not tested due to unavailability of Windows
 */
struct SinkOutputDebugString : public Sink
{
    SinkOutputDebugString(const Filter& filter) : Sink(filter)
    {
    }

    void log(const Metadata& /*metadata*/, const std::string& message) override
    {
        std::wstring wide = std::wstring(message.begin(), message.end());
        OutputDebugString(wide.c_str());
    }
};
#endif

#ifdef HAS_APPLE_UNIFIED_LOG_
/**
 * @brief
 * macOS: Logging to Apples system logger
 */
struct SinkUnifiedLogging : public Sink
{
    SinkUnifiedLogging(const Filter& filter) : Sink(filter)
    {
    }

    os_log_type_t get_os_log_type(Severity severity) const
    {
        // https://developer.apple.com/documentation/os/os_log_type_t?language=objc
        switch (severity)
        {
            case Severity::trace:
            case Severity::debug:
                return OS_LOG_TYPE_DEBUG;
            case Severity::info:
            case Severity::notice:
                return OS_LOG_TYPE_INFO;
            case Severity::warning:
                return OS_LOG_TYPE_DEFAULT;
            case Severity::error:
                return OS_LOG_TYPE_ERROR;
            case Severity::fatal:
                return OS_LOG_TYPE_FAULT;
            default:
                return OS_LOG_TYPE_DEFAULT;
        }
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        os_log_with_type(OS_LOG_DEFAULT, get_os_log_type(metadata.severity), "%{public}s", message.c_str());
    }
};
#endif

#ifdef HAS_SYSLOG_
/**
 * @brief
 * UNIX: Logging to syslog
 */
struct SinkSyslog : public Sink
{
    SinkSyslog(const char* ident, const Filter& filter) : Sink(filter)
    {
        openlog(ident, LOG_PID, LOG_USER);
    }

    ~SinkSyslog() override
    {
        closelog();
    }

    int get_syslog_priority(Severity severity) const
    {
        // http://unix.superglobalmegacorp.com/Net2/newsrc/sys/syslog.h.html
        switch (severity)
        {
            case Severity::trace:
            case Severity::debug:
                return LOG_DEBUG;
            case Severity::info:
                return LOG_INFO;
            case Severity::notice:
                return LOG_NOTICE;
            case Severity::warning:
                return LOG_WARNING;
            case Severity::error:
                return LOG_ERR;
            case Severity::fatal:
                return LOG_CRIT;
            default:
                return LOG_INFO;
        }
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        syslog(get_syslog_priority(metadata.severity), "%s", message.c_str());
    }
};
#endif

#ifdef __ANDROID__
/**
 * @brief
 * Android: Logging to android log
 *
 * Use logcat to read the logs
 */
struct SinkAndroid : public Sink
{
    SinkAndroid(const std::string& ident, const Filter& filter) : Sink(filter), ident_(ident)
    {
    }

    android_LogPriority get_android_prio(Severity severity) const
    {
        // https://developer.android.com/ndk/reference/log_8h.html
        switch (severity)
        {
            case Severity::trace:
                return ANDROID_LOG_VERBOSE;
            case Severity::debug:
                return ANDROID_LOG_DEBUG;
            case Severity::info:
            case Severity::notice:
                return ANDROID_LOG_INFO;
            case Severity::warning:
                return ANDROID_LOG_WARN;
            case Severity::error:
                return ANDROID_LOG_ERROR;
            case Severity::fatal:
                return ANDROID_LOG_FATAL;
            default:
                return ANDROID_LOG_UNKNOWN;
        }
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        std::string tag = metadata.tag ? metadata.tag.text : (metadata.function ? metadata.function.name : "");
        std::string log_tag;
        if (!ident_.empty() && !tag.empty())
            log_tag = ident_ + "." + tag;
        else if (!ident_.empty())
            log_tag = ident_;
        else if (!tag.empty())
            log_tag = tag;
        else
            log_tag = "log";

        __android_log_write(get_android_prio(metadata.severity), log_tag.c_str(), message.c_str());
    }

protected:
    std::string ident_;
};
#endif

#ifdef _WIN32
/**
 * @brief
 * Windows: Logging to event logger
 *
 * Not tested due to unavailability of Windows
 */
struct SinkEventLog : public Sink
{
    SinkEventLog(const std::string& ident, const Filter& filter) : Sink(filter)
    {
        std::wstring wide = std::wstring(ident.begin(), ident.end()); // stijnvdb: RegisterEventSource expands to RegisterEventSourceW which takes wchar_t
        event_log = RegisterEventSource(NULL, wide.c_str());
    }

    WORD get_type(Severity severity) const
    {
        // https://msdn.microsoft.com/de-de/library/windows/desktop/aa363679(v=vs.85).aspx
        switch (severity)
        {
            case Severity::trace:
            case Severity::debug:
                return EVENTLOG_INFORMATION_TYPE;
            case Severity::info:
            case Severity::notice:
                return EVENTLOG_SUCCESS;
            case Severity::warning:
                return EVENTLOG_WARNING_TYPE;
            case Severity::error:
            case Severity::fatal:
                return EVENTLOG_ERROR_TYPE;
            default:
                return EVENTLOG_INFORMATION_TYPE;
        }
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        std::wstring wide = std::wstring(message.begin(), message.end());
        // We need this temp variable because we cannot take address of rValue
        const wchar_t* c_str = wide.c_str();

        ReportEvent(event_log, get_type(metadata.severity), 0, 0, NULL, 1, 0, &c_str, NULL);
    }

protected:
    HANDLE event_log;
};
#endif

/**
 * @brief
 * Log to the system's native sys logger
 *
 * - Android: Android log
 * - macOS:   unified log
 * - Windows: event log
 * - Unix:    syslog
 */
struct SinkNative : public Sink
{
    SinkNative(const std::string& ident, const Filter& filter) : Sink(filter), log_sink_(nullptr), ident_(ident)
    {
#ifdef __ANDROID__
        log_sink_ = std::make_shared<SinkAndroid>(ident_, filter);
#elif HAS_APPLE_UNIFIED_LOG_
        log_sink_ = std::make_shared<SinkUnifiedLogging>(filter);
#elif _WIN32
        log_sink_ = std::make_shared<SinkEventLog>(ident, filter);
#elif HAS_SYSLOG_
        log_sink_ = std::make_shared<SinkSyslog>(ident_.c_str(), filter);
#else
        /// will not throw or something. Use "get_logger()" to check for success
        log_sink_ = nullptr;
#endif
    }

    virtual log_sink_ptr get_logger()
    {
        return log_sink_;
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        if (log_sink_ != nullptr)
            log_sink_->log(metadata, message);
    }

protected:
    log_sink_ptr log_sink_;
    std::string ident_;
};

/**
 * @brief
 * Forward log messages to a callback function
 *
 * Pass the callback function to the c'tor.
 * This can be any function that matches the signature of "callback_fun"
 * Might also be a lambda function
 */
struct SinkCallback : public Sink
{
    using callback_fun = std::function<void(const Metadata& metadata, const std::string& message)>;

    SinkCallback(const Filter& filter, callback_fun callback) : Sink(filter), callback_(callback)
    {
    }

    void log(const Metadata& metadata, const std::string& message) override
    {
        if (callback_)
            callback_(metadata, message);
    }

private:
    callback_fun callback_;
};

/**
 * @brief
 * ostream << operator for "Severity"
 *
 * Severity must be the first thing that is logged into clog, since it will reset the loggers metadata.
 */
static std::ostream& operator<<(std::ostream& os, const Severity& log_severity)
{
    Log* log = dynamic_cast<Log*>(os.rdbuf());
    if (log != nullptr)
    {
        std::lock_guard<std::recursive_mutex> lock(log->mutex_);
        if (log->metadata_.severity != log_severity)
        {
            log->sync();
            log->metadata_.severity = log_severity;
            log->metadata_.timestamp = nullptr;
            log->metadata_.tag = nullptr;
            log->metadata_.function = nullptr;
            log->conditional_.set(true);
        }
    }
    else
    {
        os << to_string(log_severity);
    }
    return os;
}

static std::ostream& operator<<(std::ostream& os, const Timestamp& timestamp)
{
    Log* log = dynamic_cast<Log*>(os.rdbuf());
    if (log != nullptr)
    {
        std::lock_guard<std::recursive_mutex> lock(log->mutex_);
        log->metadata_.timestamp = timestamp;
    }
    else if (timestamp)
    {
        os << timestamp.to_string();
    }
    return os;
}

static std::ostream& operator<<(std::ostream& os, const Tag& tag)
{
    Log* log = dynamic_cast<Log*>(os.rdbuf());
    if (log != nullptr)
    {
        std::lock_guard<std::recursive_mutex> lock(log->mutex_);
        log->metadata_.tag = tag;
    }
    else if (tag)
    {
        os << tag.text;
    }
    return os;
}

static std::ostream& operator<<(std::ostream& os, const Function& function)
{
    Log* log = dynamic_cast<Log*>(os.rdbuf());
    if (log != nullptr)
    {
        std::lock_guard<std::recursive_mutex> lock(log->mutex_);
        log->metadata_.function = function;
    }
    else if (function)
    {
        os << function.name;
    }
    return os;
}

static std::ostream& operator<<(std::ostream& os, const Conditional& conditional)
{
    Log* log = dynamic_cast<Log*>(os.rdbuf());
    if (log != nullptr)
    {
        std::lock_guard<std::recursive_mutex> lock(log->mutex_);
        log->conditional_.set(conditional.is_true());
    }
    return os;
}

static std::ostream& operator<<(std::ostream& os, const TextColor& text_color)
{
    os << "\033[";
    if ((text_color.foreground == Color::none) && (text_color.background == Color::none))
        os << "0"; // reset colors if no params

    if (text_color.foreground != Color::none)
    {
        os << 29 + static_cast<int>(text_color.foreground);
        if (text_color.background != Color::none)
            os << ";";
    }
    if (text_color.background != Color::none)
        os << 39 + static_cast<int>(text_color.background);
    os << "m";

    return os;
}

static std::ostream& operator<<(std::ostream& os, const Color& color)
{
    os << TextColor(color);
    return os;
}

} // namespace AixLog

#ifdef _WIN32
// We restore the ERROR Windows macro
#pragma pop_macro("ERROR")
#pragma pop_macro("DEBUG")
#endif

#endif // AIX_LOG_HPP
