/// @file dpf/log.hpp
/// @brief Leveled run log: one `key=value` line per record, written to
///        stderr, syslog, or a file.
/// @details Nothing is written until `log::configure` runs (normally through
///          `app::start_logging`), so library code logs freely and a test or
///          embedder that never configures the log stays quiet.
///
///          A record is built in a local string and written with one
///          `write(2)` per sink, so party threads, and party processes that
///          append to one file, never interleave inside a line. Every line
///          starts with `ts=<UTC, microseconds> lvl=<level> inv=<invocation id>
///          pid=<pid> tid=<kernel thread id>`, then `role=<party>` when the
///          thread has one (`role_scope`), then `ev=<event>` and the event's
///          fields. A value with a space, quote, `=`, backslash, or control
///          character is double-quoted with backslash escapes.
///
///          Seed bytes go through `record::seed`, which prints them as hex, as
///          a SHA-256 fingerprint, or not at all, per `settings::seeds`.
///
///          Levels, from quiet to loud: `silent`, `error`, `warning`, `info`,
///          `debug`, `trace` (or `0`-`5`; `warn` and `absurd` are accepted as
///          aliases). `DPF_LOG(level, "event").kv("key", value)` builds the
///          record only when that level is enabled.
#ifndef LIBDPF_INCLUDE_DPF_LOG_HPP__
#define LIBDPF_INCLUDE_DPF_LOG_HPP__

#include <array>
#include <atomic>
#include <cerrno>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <functional>
#include <mutex>
#include <random>
#include <set>
#include <stdexcept>
#include <string>
#include <thread>
#include <type_traits>
#include <utility>

#include <fcntl.h>
#include <sys/types.h>
#include <unistd.h>

#if defined(__linux__)
#include <sys/syscall.h>
#endif

#if defined(__has_include)
#if __has_include(<syslog.h>)
#include <syslog.h>
#define DPF_LOG_HAS_SYSLOG 1
#endif
#endif
#ifndef DPF_LOG_HAS_SYSLOG
#define DPF_LOG_HAS_SYSLOG 0
#endif

namespace dpf
{
namespace log
{

enum class level : unsigned char
{
    silent = 0,
    error = 1,
    warning = 2,
    info = 3,
    debug = 4,
    trace = 5
};

inline const char * level_name(level l) noexcept
{
    switch (l)
    {
    case level::silent:
        return "silent";
    case level::error:
        return "error";
    case level::warning:
        return "warning";
    case level::info:
        return "info";
    case level::debug:
        return "debug";
    case level::trace:
        return "trace";
    }
    return "info";
}

/// @brief Parse a level name or digit. Unknown names throw.
inline level parse_level(const std::string & s)
{
    if (s == "silent" || s == "none" || s == "off" || s == "0")
        return level::silent;
    if (s == "error" || s == "1")
        return level::error;
    if (s == "warning" || s == "warn" || s == "2")
        return level::warning;
    if (s == "info" || s == "3")
        return level::info;
    if (s == "debug" || s == "4")
        return level::debug;
    if (s == "trace" || s == "absurd" || s == "5")
        return level::trace;
    throw std::invalid_argument("unknown log level: " + s
        + " (silent|error|warning|info|debug|trace or 0-5)");
}

/// @brief How seed bytes appear in records.
enum class seed_policy : unsigned char
{
    full,  ///< the bytes as hex: the run can be replayed from the log
    hash,  ///< a SHA-256 fingerprint: runs can be compared, not replayed
    off    ///< neither; the field reads `withheld`
};

inline const char * seed_policy_name(seed_policy p) noexcept
{
    switch (p)
    {
    case seed_policy::full:
        return "full";
    case seed_policy::hash:
        return "hash";
    case seed_policy::off:
        return "off";
    }
    return "full";
}

inline seed_policy parse_seed_policy(const std::string & s)
{
    if (s == "full" || s == "hex" || s == "1")
        return seed_policy::full;
    if (s == "hash" || s == "fingerprint" || s == "sha256")
        return seed_policy::hash;
    if (s == "off" || s == "none" || s == "0")
        return seed_policy::off;
    throw std::invalid_argument("unknown log_seeds: " + s + " (full|hash|off)");
}

struct settings
{
    level threshold = level::info;
    /// Comma-separated sinks: `stderr`, `syslog`, `file:PATH`, or `none`.
    /// One file at most; it is opened for append, so parties may share it.
    std::string sinks = "stderr";
    seed_policy seeds = seed_policy::full;
    /// syslog identity (facility `LOG_USER`).
    std::string ident = "libdpf";
};

namespace detail
{

inline std::atomic<unsigned> threshold{0};
inline std::atomic<unsigned char> seeds{0};

struct sinks_state
{
    std::mutex mu;
    bool to_stderr = false;
    bool to_syslog = false;
    int fd = -1;
    std::string path;
    std::string ident;
    std::set<std::string> said;

    sinks_state() = default;
    sinks_state(const sinks_state &) = delete;
    sinks_state & operator=(const sinks_state &) = delete;

    ~sinks_state()
    {
        threshold.store(0, std::memory_order_relaxed);
        if (fd >= 0)
            ::close(fd);
#if DPF_LOG_HAS_SYSLOG
        if (to_syslog)
            ::closelog();
#endif
    }
};

inline sinks_state & sinks()
{
    static sinks_state s;
    return s;
}

inline thread_local std::string role_tls;

inline long kernel_tid() noexcept
{
#if defined(__linux__) && defined(SYS_gettid)
    static thread_local const long tid = static_cast<long>(::syscall(SYS_gettid));
    return tid;
#else
    return static_cast<long>(
        std::hash<std::thread::id>{}(std::this_thread::get_id()) & 0x7fffffffu);
#endif
}

/// @brief `YYYY-MM-DDTHH:MM:SS.uuuuuuZ` for `tp`.
inline std::string utc_text(std::chrono::system_clock::time_point tp)
{
    const auto us = std::chrono::duration_cast<std::chrono::microseconds>(
        tp.time_since_epoch()).count();
    const std::time_t secs = static_cast<std::time_t>(us / 1000000);
    const auto frac = static_cast<unsigned>((us % 1000000 + 1000000) % 1000000);
    std::tm tm{};
    ::gmtime_r(&secs, &tm);
    char buf[96];
    std::snprintf(buf, sizeof(buf), "%04d-%02d-%02dT%02d:%02d:%02d.%06uZ",
        tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday, tm.tm_hour, tm.tm_min,
        tm.tm_sec, frac);
    return buf;
}

inline void append_value(std::string & out, const char * p, std::size_t n)
{
    bool plain = n != 0;
    for (std::size_t i = 0; i < n && plain; ++i)
    {
        const auto c = static_cast<unsigned char>(p[i]);
        plain = c > 0x20 && c < 0x7f && c != '"' && c != '=' && c != '\\';
    }
    if (plain)
    {
        out.append(p, n);
        return;
    }
    out += '"';
    for (std::size_t i = 0; i < n; ++i)
    {
        const auto c = static_cast<unsigned char>(p[i]);
        switch (c)
        {
        case '"':
            out += "\\\"";
            break;
        case '\\':
            out += "\\\\";
            break;
        case '\n':
            out += "\\n";
            break;
        case '\r':
            out += "\\r";
            break;
        case '\t':
            out += "\\t";
            break;
        default:
            if (c < 0x20 || c == 0x7f)
            {
                char esc[5];
                std::snprintf(esc, sizeof(esc), "\\x%02x", c);
                out += esc;
            }
            else
                out += static_cast<char>(c);
        }
    }
    out += '"';
}

inline void append_hex(std::string & out, const std::uint8_t * p, std::size_t n)
{
    static const char digits[] = "0123456789abcdef";
    for (std::size_t i = 0; i < n; ++i)
    {
        out += digits[p[i] >> 4];
        out += digits[p[i] & 0x0f];
    }
}

/// @brief SHA-256 of `label || data` (FIPS 180-4), for seed fingerprints.
inline std::array<std::uint8_t, 32> sha256(const char * label,
    const std::uint8_t * data, std::size_t n)
{
    static constexpr std::uint32_t k[64] = {
        0x428a2f98u, 0x71374491u, 0xb5c0fbcfu, 0xe9b5dba5u, 0x3956c25bu,
        0x59f111f1u, 0x923f82a4u, 0xab1c5ed5u, 0xd807aa98u, 0x12835b01u,
        0x243185beu, 0x550c7dc3u, 0x72be5d74u, 0x80deb1feu, 0x9bdc06a7u,
        0xc19bf174u, 0xe49b69c1u, 0xefbe4786u, 0x0fc19dc6u, 0x240ca1ccu,
        0x2de92c6fu, 0x4a7484aau, 0x5cb0a9dcu, 0x76f988dau, 0x983e5152u,
        0xa831c66du, 0xb00327c8u, 0xbf597fc7u, 0xc6e00bf3u, 0xd5a79147u,
        0x06ca6351u, 0x14292967u, 0x27b70a85u, 0x2e1b2138u, 0x4d2c6dfcu,
        0x53380d13u, 0x650a7354u, 0x766a0abbu, 0x81c2c92eu, 0x92722c85u,
        0xa2bfe8a1u, 0xa81a664bu, 0xc24b8b70u, 0xc76c51a3u, 0xd192e819u,
        0xd6990624u, 0xf40e3585u, 0x106aa070u, 0x19a4c116u, 0x1e376c08u,
        0x2748774cu, 0x34b0bcb5u, 0x391c0cb3u, 0x4ed8aa4au, 0x5b9cca4fu,
        0x682e6ff3u, 0x748f82eeu, 0x78a5636fu, 0x84c87814u, 0x8cc70208u,
        0x90befffau, 0xa4506cebu, 0xbef9a3f7u, 0xc67178f2u};
    std::uint32_t h[8] = {0x6a09e667u, 0xbb67ae85u, 0x3c6ef372u, 0xa54ff53au,
        0x510e527fu, 0x9b05688cu, 0x1f83d9abu, 0x5be0cd19u};
    std::string m(label == nullptr ? "" : label);
    m.append(reinterpret_cast<const char *>(data), n);
    const std::uint64_t bits = static_cast<std::uint64_t>(m.size()) * 8u;
    m += static_cast<char>(0x80);
    while (m.size() % 64 != 56)
        m += '\0';
    for (int i = 7; i >= 0; --i)
        m += static_cast<char>((bits >> (8 * i)) & 0xffu);
    auto rotr = [](std::uint32_t x, int r) { return (x >> r) | (x << (32 - r)); };
    for (std::size_t off = 0; off < m.size(); off += 64)
    {
        std::uint32_t w[64];
        for (int i = 0; i < 16; ++i)
        {
            const auto * b = reinterpret_cast<const unsigned char *>(m.data() + off + 4 * i);
            w[i] = (static_cast<std::uint32_t>(b[0]) << 24)
                | (static_cast<std::uint32_t>(b[1]) << 16)
                | (static_cast<std::uint32_t>(b[2]) << 8) | static_cast<std::uint32_t>(b[3]);
        }
        for (int i = 16; i < 64; ++i)
        {
            const std::uint32_t s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >> 3);
            const std::uint32_t s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >> 10);
            w[i] = w[i - 16] + s0 + w[i - 7] + s1;
        }
        std::uint32_t a = h[0], b = h[1], c = h[2], d = h[3];
        std::uint32_t e = h[4], f = h[5], g = h[6], hh = h[7];
        for (int i = 0; i < 64; ++i)
        {
            const std::uint32_t s1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
            const std::uint32_t ch = (e & f) ^ (~e & g);
            const std::uint32_t t1 = hh + s1 + ch + k[i] + w[i];
            const std::uint32_t s0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
            const std::uint32_t mj = (a & b) ^ (a & c) ^ (b & c);
            const std::uint32_t t2 = s0 + mj;
            hh = g;
            g = f;
            f = e;
            e = d + t1;
            d = c;
            c = b;
            b = a;
            a = t1 + t2;
        }
        h[0] += a;
        h[1] += b;
        h[2] += c;
        h[3] += d;
        h[4] += e;
        h[5] += f;
        h[6] += g;
        h[7] += hh;
    }
    std::array<std::uint8_t, 32> out{};
    for (int i = 0; i < 8; ++i)
        for (int j = 0; j < 4; ++j)
            out[static_cast<std::size_t>(4 * i + j)] =
                static_cast<std::uint8_t>((h[i] >> (24 - 8 * j)) & 0xffu);
    return out;
}

#if DPF_LOG_HAS_SYSLOG
inline int syslog_priority(level l) noexcept
{
    switch (l)
    {
    case level::error:
        return LOG_ERR;
    case level::warning:
        return LOG_WARNING;
    case level::info:
        return LOG_INFO;
    default:
        return LOG_DEBUG;
    }
}
#endif

inline void write_all(int fd, const char * p, std::size_t n) noexcept
{
    while (n > 0)
    {
        const ssize_t r = ::write(fd, p, n);
        if (r > 0)
        {
            p += r;
            n -= static_cast<std::size_t>(r);
            continue;
        }
        if (r < 0 && errno == EINTR)
            continue;
        return;
    }
}

inline void emit(level l, std::string & line) noexcept
{
    try
    {
        line += '\n';
        auto & s = sinks();
        std::lock_guard<std::mutex> lock(s.mu);
        if (s.to_stderr)
            write_all(STDERR_FILENO, line.data(), line.size());
        if (s.fd >= 0)
            write_all(s.fd, line.data(), line.size());
#if DPF_LOG_HAS_SYSLOG
        if (s.to_syslog)
            ::syslog(syslog_priority(l), "%.*s", static_cast<int>(line.size() - 1),
                line.data());
#else
        (void)l;
#endif
    }
    catch (...)
    {
    }
}

}  // namespace detail

/// @brief True when records at `l` are written somewhere.
inline bool enabled(level l) noexcept
{
    return l != level::silent
        && static_cast<unsigned>(l) <= detail::threshold.load(std::memory_order_relaxed);
}

inline seed_policy seeds() noexcept
{
    return static_cast<seed_policy>(detail::seeds.load(std::memory_order_relaxed));
}

/// @brief Random per-process id stamped on every record (and on CSV rows that
///        want to point back at the log). Drawn once from `std::random_device`,
///        never from `dpf::uniform_fill`, so it does not perturb seed streams
///        or random-byte counts.
inline const std::string & invocation_id()
{
    static const std::string id = [] {
        std::uint64_t v = 0;
        try
        {
            std::random_device rd;
            v = (static_cast<std::uint64_t>(rd()) << 32) ^ rd();
        }
        catch (...)
        {
            v = static_cast<std::uint64_t>(
                    std::chrono::system_clock::now().time_since_epoch().count())
                ^ (static_cast<std::uint64_t>(::getpid()) << 40);
        }
        std::string out;
        std::uint8_t b[8];
        for (int i = 0; i < 8; ++i)
            b[i] = static_cast<std::uint8_t>((v >> (56 - 8 * i)) & 0xffu);
        detail::append_hex(out, b, 8);
        return out;
    }();
    return id;
}

/// @brief Apply `cfg`. A bad sink name or unopenable file throws and leaves the
///        previous configuration in place. `none` (or no sinks) silences.
inline void configure(const settings & cfg)
{
    bool want_stderr = false;
    bool want_syslog = false;
    std::string path;
    std::size_t start = 0;
    while (start <= cfg.sinks.size())
    {
        const auto comma = cfg.sinks.find(',', start);
        std::string tok = cfg.sinks.substr(start,
            comma == std::string::npos ? std::string::npos : comma - start);
        while (!tok.empty() && tok.front() == ' ')
            tok.erase(tok.begin());
        while (!tok.empty() && tok.back() == ' ')
            tok.pop_back();
        if (tok == "stderr")
            want_stderr = true;
        else if (tok == "syslog")
            want_syslog = true;
        else if (tok.rfind("file:", 0) == 0 && tok.size() > 5)
            path = tok.substr(5);
        else if (!tok.empty() && tok != "none")
            throw std::invalid_argument("unknown log sink '" + tok
                + "' (stderr|syslog|file:PATH|none)");
        if (comma == std::string::npos)
            break;
        start = comma + 1;
    }
#if !DPF_LOG_HAS_SYSLOG
    if (want_syslog)
        throw std::invalid_argument("log sink 'syslog' is not available here");
#endif
    (void)invocation_id();
    auto & s = detail::sinks();
    std::lock_guard<std::mutex> lock(s.mu);
    int fd = -1;
    if (!path.empty())
    {
        if (path == s.path && s.fd >= 0)
            fd = s.fd;
        else
        {
            fd = ::open(path.c_str(), O_WRONLY | O_CREAT | O_APPEND | O_CLOEXEC, 0640);
            if (fd < 0)
                throw std::runtime_error("log: cannot open '" + path + "': "
                    + std::strerror(errno));
        }
    }
    if (s.fd >= 0 && s.fd != fd)
        ::close(s.fd);
    s.fd = fd;
    s.path = path;
#if DPF_LOG_HAS_SYSLOG
    if (s.to_syslog && (!want_syslog || s.ident != cfg.ident))
    {
        ::closelog();
        s.to_syslog = false;
    }
    if (want_syslog && !s.to_syslog)
    {
        s.ident = cfg.ident;
        ::openlog(s.ident.c_str(), LOG_PID | LOG_NDELAY, LOG_USER);
    }
#endif
    s.to_syslog = want_syslog;
    s.to_stderr = want_stderr;
    detail::seeds.store(static_cast<unsigned char>(cfg.seeds), std::memory_order_relaxed);
    const bool any = want_stderr || want_syslog || fd >= 0;
    detail::threshold.store(any ? static_cast<unsigned>(cfg.threshold) : 0u,
        std::memory_order_relaxed);
}

/// @brief True the first time `key` is seen in this process (for one-shot
///        warnings from code that runs per trial or per cell).
inline bool first_time(const std::string & key)
{
    auto & s = detail::sinks();
    std::lock_guard<std::mutex> lock(s.mu);
    return s.said.insert(key).second;
}

/// @brief The party role stamped on this thread's records (`p0`, `p1`, `p2`).
inline const std::string & role() noexcept { return detail::role_tls; }

/// @brief Set this thread's role for the scope's lifetime.
class role_scope
{
public:
    explicit role_scope(std::string role) : prev_(std::move(detail::role_tls))
    {
        detail::role_tls = std::move(role);
    }
    ~role_scope() { detail::role_tls = std::move(prev_); }
    role_scope(const role_scope &) = delete;
    role_scope & operator=(const role_scope &) = delete;

private:
    std::string prev_;
};

/// @brief One log line. Written when it goes out of scope.
class record
{
public:
    record(level l, const char * event) : level_(l)
    {
        line_.reserve(256);
        line_ += "ts=";
        line_ += detail::utc_text(std::chrono::system_clock::now());
        line_ += " lvl=";
        line_ += level_name(l);
        line_ += " inv=";
        line_ += invocation_id();
        line_ += " pid=";
        line_ += std::to_string(::getpid());
        line_ += " tid=";
        line_ += std::to_string(detail::kernel_tid());
        if (!detail::role_tls.empty())
        {
            line_ += " role=";
            detail::append_value(line_, detail::role_tls.data(), detail::role_tls.size());
        }
        line_ += " ev=";
        const char * ev = event == nullptr ? "event" : event;
        detail::append_value(line_, ev, std::strlen(ev));
    }

    record(const record &) = delete;
    record & operator=(const record &) = delete;

    ~record() { detail::emit(level_, line_); }

    record & kv(const char * key, const std::string & v)
    {
        key_(key);
        detail::append_value(line_, v.data(), v.size());
        return *this;
    }

    record & kv(const char * key, const char * v)
    {
        key_(key);
        const char * p = v == nullptr ? "" : v;
        detail::append_value(line_, p, std::strlen(p));
        return *this;
    }

    record & kv(const char * key, bool v)
    {
        key_(key);
        line_ += v ? '1' : '0';
        return *this;
    }

    template <typename T,
              std::enable_if_t<std::is_integral_v<T> && !std::is_same_v<T, bool>, int> = 0>
    record & kv(const char * key, T v)
    {
        key_(key);
        line_ += std::to_string(v);
        return *this;
    }

    template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
    record & kv(const char * key, T v)
    {
        key_(key);
        char buf[32];
        std::snprintf(buf, sizeof(buf), "%.6g", static_cast<double>(v));
        line_ += buf;
        return *this;
    }

    record & hex(const char * key, const void * bytes, std::size_t n)
    {
        key_(key);
        if (n == 0 || bytes == nullptr)
            line_ += "\"\"";
        else
            detail::append_hex(line_, static_cast<const std::uint8_t *>(bytes), n);
        return *this;
    }

    /// @brief Seed bytes under the configured `seed_policy`.
    record & seed(const char * key, const void * bytes, std::size_t n)
    {
        switch (seeds())
        {
        case seed_policy::full:
            return hex(key, bytes, n);
        case seed_policy::hash:
        {
            const auto d = detail::sha256("libdpf seed fingerprint",
                static_cast<const std::uint8_t *>(bytes), bytes == nullptr ? 0 : n);
            key_(key);
            line_ += "sha256:";
            detail::append_hex(line_, d.data(), 8);
            return *this;
        }
        case seed_policy::off:
            break;
        }
        key_(key);
        line_ += "withheld";
        return *this;
    }

private:
    void key_(const char * key)
    {
        line_ += ' ';
        line_ += key == nullptr ? "field" : key;
        line_ += '=';
    }

    level level_;
    std::string line_;
};

}  // namespace log
}  // namespace dpf

/// @brief `DPF_LOG(info, "event").kv("key", value)`: the record and its
///        arguments are only evaluated when `info` is enabled. The single-pass
///        `for` has no `else` to pair with an enclosing unbraced `if`.
#define DPF_LOG(LEVEL, EVENT)                                                  \
    for (bool dpf_log_on_ = ::dpf::log::enabled(::dpf::log::level::LEVEL);     \
         dpf_log_on_; dpf_log_on_ = false)                                     \
        ::dpf::log::record(::dpf::log::level::LEVEL, EVENT)

#endif  // LIBDPF_INCLUDE_DPF_LOG_HPP__