#include "log.hpp"

#include <cstring>

namespace Log {

namespace {
    bool g_verbose = false;
    bool g_serverVerbose = false;

    void VPrint(const char* prefix, const char* fmt, va_list args) {
        std::fprintf(stdout, "%s ", prefix);
        std::vfprintf(stdout, fmt, args);
        std::fprintf(stdout, "\n");
        std::fflush(stdout);
    }

    void VPrintIf(bool enabled, const char* prefix, const char* fmt, va_list args) {
        if (!enabled) {
            return;
        }
        VPrint(prefix, fmt, args);
    }
} // namespace

void SetVerbose(bool enabled) {
    g_verbose = enabled;
}

void SetServerVerbose(bool enabled) {
    g_serverVerbose = enabled;
}

bool IsVerbose() {
    return g_verbose;
}

bool IsServerVerbose() {
    return g_serverVerbose;
}

void Ok(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    VPrint("[+]", fmt, args);
    va_end(args);
}

void Warn(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    VPrint("[!]", fmt, args);
    va_end(args);
}

void Err(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    VPrint("[x]", fmt, args);
    va_end(args);
}

void Info(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    VPrintIf(g_verbose, "[*]", fmt, args);
    va_end(args);
}

void Dbg(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    VPrintIf(g_verbose, "[-]", fmt, args);
    va_end(args);
}

void Sys(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    VPrintIf(g_verbose, "[@]", fmt, args);
    va_end(args);
}

void Raw(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    VPrintIf(g_verbose, "[@]", fmt, args);
    va_end(args);
}

void Banner(const char* title) {
    if (!g_verbose) {
        return;
    }
    std::fprintf(stdout, "\n[@] === %s ===\n", title);
    std::fflush(stdout);
}

void NtStatus(const char* tag, long status) {
    if (!g_verbose) {
        return;
    }
    std::fprintf(stdout, "[@] %s NTSTATUS=0x%08lX (%s)\n", tag,
        static_cast<unsigned long>(status),
        status >= 0 ? "SUCCESS" : "FAIL");
    std::fflush(stdout);
}

void HexPreview(const char* tag, const void* data, size_t len, size_t maxBytes) {
    if (!g_verbose || !data || len == 0) {
        return;
    }
    const auto* p = static_cast<const unsigned char*>(data);
    const size_t n = len < maxBytes ? len : maxBytes;
    std::fprintf(stdout, "[@] %s hex[%zu/%zu]: ", tag, n, len);
    for (size_t i = 0; i < n; ++i) {
        std::fprintf(stdout, "%02X ", p[i]);
    }
    if (len > maxBytes) {
        std::fprintf(stdout, "...");
    }
    std::fprintf(stdout, "\n");
    std::fflush(stdout);
}

void Srv(const char* fmt, ...) {
    va_list args;
    va_start(args, fmt);
    VPrintIf(g_serverVerbose, "[S]", fmt, args);
    va_end(args);
}

void SrvBanner(const char* title) {
    if (!g_serverVerbose) {
        return;
    }
    std::fprintf(stdout, "\n[S] === %s ===\n", title);
    std::fflush(stdout);
}

} // namespace Log