util.h

/*
 * Copyright (C) 2025 James C. Owens
 * Portions Copyright (c) 2019 The Bitcoin Core developers
 * Portions Copyright (c) 2025 The Gridcoin developers
 *
 * This code is licensed under the MIT license. See LICENSE.md in the repository.
 */

#ifndef UTIL_H
#define UTIL_H

#include <atomic>
#include <map>
#include <mutex>
#include <optional>
#include <tinyformat.h>
#include <variant>
#include <vector>
#include <filesystem>

namespace fs = std::filesystem;

extern std::atomic<bool> g_debug;
extern std::atomic<bool> g_log_timestamps;

template <typename T>
std::string ToString(const T& t)
{
    std::ostringstream oss;
    oss.imbue(std::locale::classic());
    oss << t;
    return oss.str();
}

[[nodiscard]] std::vector<std::string> StringSplit(const std::string& s, const std::string& delim);

[[nodiscard]] std::string TrimString(const std::string& str, const std::string& pattern = " \f\n\r\t\v");

[[nodiscard]] std::string StripQuotes(const std::string& str);

constexpr char ToLower(char c);

std::string ToLower(const std::string& str);

int64_t GetUnixEpochTime();

std::string FormatISO8601DateTime(int64_t time);

bool IsValidTimestamp(const int64_t& timestamp);

template <typename... Args>
static inline std::string LogPrintStr(const char* fmt, const Args&... args)
{
    std::string log_msg;

    // Conditionally add timestamp prefix based on g_log_timestamps flag.
    if (g_log_timestamps.load(std::memory_order_relaxed)) { // Check the flag
        log_msg = FormatISO8601DateTime(GetUnixEpochTime()) + " ";
    }

    try {
        log_msg += tfm::format(fmt, args...);
    } catch (tinyformat::format_error& fmterr) {
        /* Original format string will have newline so don't add one here */
        log_msg += "Error \"" + std::string(fmterr.what()) + "\" while formatting log message: " + fmt;
    }

    log_msg += "\n";

    return log_msg;
}

template <typename... Args>
void normal_log(const char* fmt, const Args&... args)
{
    std::cout << LogPrintStr(fmt, args...);
}

template <typename... Args>
void debug_log(const char* fmt, const Args&... args)
{
    if (g_debug.load()) {
        normal_log(fmt, args...);
    }
}

template <typename... Args>
void error_log(const char* fmt, const Args&... args)
{
    std::string error_fmt = "ERROR: ";
    error_fmt += fmt;

    std::cerr << LogPrintStr(error_fmt.c_str(), args...);
}

[[nodiscard]] int ParseStringToInt(const std::string& str);

[[nodiscard]] int64_t ParseStringtoInt64(const std::string& str);

std::vector<fs::path> FindDirEntriesWithWildcard(const fs::path& directory, const std::string& wildcard);

std::optional<std::string> GetEnvVariable(const std::string& var_name);

class EventIdleDetectException : public std::exception
{
public:
    EventIdleDetectException(const std::string& message) : m_message(message) {}
    EventIdleDetectException(const char* message) : m_message(message) {}

    const char* what() const noexcept override {
        return m_message.c_str();
    }

protected:
    std::string m_message;
};

class FileSystemException : public EventIdleDetectException
{
public:
    FileSystemException(const std::string& message, const std::filesystem::path& path)
        : EventIdleDetectException(message + " Path: " + path.string()), m_path(path) {}

    const std::filesystem::path& path() const { return m_path; }

private:
    std::filesystem::path m_path;
};

class ThreadException : public EventIdleDetectException
{
public:
    ThreadException(const std::string& message) : EventIdleDetectException(message) {}
};

typedef std::variant<bool, int, std::string, fs::path> config_variant;

class Config
{
public:
    Config();

    void ReadAndUpdateConfig(const fs::path& config_file);

    config_variant GetArg(const std::string& arg);

protected:
    std::string GetArgString(const std::string& arg, const std::string& default_value) const;

    std::multimap<std::string, config_variant> m_config;

private:
    virtual void ProcessArgs() = 0;


    mutable std::mutex mtx_config;

    std::multimap<std::string, std::string> m_config_in;

};

class EventMessage
{
public:
    enum EventType { // Note that if this enum is expanded, EventTypeToString must also be updated.
        UNKNOWN,
        USER_ACTIVE,
        USER_UNFORCE,
        USER_FORCE_ACTIVE,
        USER_FORCE_IDLE
    };

    EventMessage();

    EventMessage(int64_t timestamp, EventType event_type);

    EventMessage(std::string timestamp_str, std::string event_type_str);

    std::string EventTypeToString();

    static std::string EventTypeToString(const EventType& event_type);

    bool IsValid();

    std::string ToString();

    int64_t m_timestamp;
    EventType m_event_type;

private:
    EventType EventTypeStringToEnum(const std::string& event_type_str);
};


#endif // UTIL_H