TimeUtils.cpp

Go to the documentation of this file.

#include <CS2Kit/Utils/TimeUtils.hpp>
#include <algorithm>
#include <cctype>
#include <chrono>
#include <format>
#include <regex>
 
namespace CS2Kit::Utils
{
 
int64_t TimeUtils::Now()
{
    auto now = std::chrono::system_clock::now();
    return std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count();
}
 
int64_t TimeUtils::ParseDuration(const std::string& duration)
{
    std::string lower = duration;
    std::transform(lower.begin(), lower.end(), lower.begin(), ::tolower);
 
    if (lower.empty() || lower == "0" || lower == "perm" || lower == "permanent")
        return 0;
 
    std::regex pattern(R"((\d+)([smhdw]))");
    std::smatch matches;
    if (std::regex_match(lower, matches, pattern))
    {
        try
        {
            int64_t value = std::stoll(matches[1].str());
            switch (matches[2].str()[0])
            {
            case 's':
                return value;
            case 'm':
                return value * SecondsPerMinute;
            case 'h':
                return value * SecondsPerHour;
            case 'd':
                return value * SecondsPerDay;
            case 'w':
                return value * SecondsPerWeek;
            default:
                return 0;
            }
        }
        catch (...)
        {
            return 0;
        }
    }
 
    try
    {
        return std::stoll(duration);
    }
    catch (...)
    {
        return 0;
    }
}
 
std::string TimeUtils::FormatDuration(int64_t seconds)
{
    if (seconds == 0)
        return "Permanent";
 
    if (seconds % SecondsPerWeek == 0 && seconds >= SecondsPerWeek)
    {
        int64_t w = seconds / SecondsPerWeek;
        return std::format("{} week{}", w, w > 1 ? "s" : "");
    }
    if (seconds % SecondsPerDay == 0 && seconds >= SecondsPerDay)
    {
        int64_t d = seconds / SecondsPerDay;
        return std::format("{} day{}", d, d > 1 ? "s" : "");
    }
    if (seconds % SecondsPerHour == 0 && seconds >= SecondsPerHour)
    {
        int64_t h = seconds / SecondsPerHour;
        return std::format("{} hour{}", h, h > 1 ? "s" : "");
    }
    if (seconds % SecondsPerMinute == 0 && seconds >= SecondsPerMinute)
    {
        int64_t m = seconds / SecondsPerMinute;
        return std::format("{} minute{}", m, m > 1 ? "s" : "");
    }
    return std::format("{} second{}", seconds, seconds > 1 ? "s" : "");
}
 
std::string TimeUtils::FormatTimestamp(int64_t timestamp)
{
    if (timestamp == 0)
        return "Never";
 
    std::time_t time = static_cast<std::time_t>(timestamp);
    std::tm tm;
#ifdef _WIN32
    localtime_s(&tm, &time);
#else
    localtime_r(&time, &tm);
#endif
    return std::format("{:04d}-{:02d}-{:02d} {:02d}:{:02d}:{:02d}", tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
                       tm.tm_hour, tm.tm_min, tm.tm_sec);
}
 
bool TimeUtils::IsExpired(int64_t expiresAt)
{
    if (expiresAt == 0)
        return false;
    return Now() >= expiresAt;
}
 
int64_t TimeUtils::GetExpirationTime(int64_t durationSeconds)
{
    if (durationSeconds == 0)
        return 0;
    return Now() + durationSeconds;
}
 
}  // namespace CS2Kit::Utils