DateTimeFormat.h

/*
 * Copyright (C) 2025, Robert Patterson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <string>
#include <cstring>
#include <ctime>
 
#ifdef MUSX_RUNNING_ON_WINDOWS
#include <windows.h>
#else
#include <locale>
#include <sstream>
#include <iomanip>
#include <langinfo.h>
#endif
 
#include "musx/dom/EnumClasses.h"
 
namespace musx {
namespace util {
 
struct DateTime
{
    using DateFormat = musx::dom::DateFormat;   
 
    inline static std::time_t makeTimeT(int year, int month, int day)
    {
        std::tm tm = {};
        tm.tm_year = year - 1900; // tm_year is years since 1900
        tm.tm_mon = month - 1;    // tm_mon is 0-based
        tm.tm_mday = day;
        tm.tm_hour = 0;
        tm.tm_min = 0;
        tm.tm_sec = 0;
        tm.tm_isdst = -1; // Let system determine daylight saving time
 
        return std::mktime(&tm);
    }
 
#ifdef MUSX_RUNNING_ON_WINDOWS
    inline static std::string formatDate(std::time_t t, DateFormat style)
    {
        SYSTEMTIME st;
        {
            struct tm tm;
            localtime_s(&tm, &t);
            st.wYear = WORD(tm.tm_year + 1900);
            st.wMonth = WORD(tm.tm_mon + 1);
            st.wDay = WORD(tm.tm_mday);
            st.wHour = WORD(tm.tm_hour);
            st.wMinute = WORD(tm.tm_min);
            st.wSecond = WORD(tm.tm_sec);
            st.wMilliseconds = 0;
        }
 
        // Determine flags and custom format string
        DWORD flags = 0;
        const wchar_t* customFormat = nullptr;
 
        switch (style)
        {
        case DateFormat::Short:
            flags = DATE_SHORTDATE;
            break;
 
        case DateFormat::Long:
            flags = DATE_LONGDATE;
            break;
 
        case DateFormat::Abbrev:
            // Windows does not provide a built-in long abbreviated date, so use custom format string
            customFormat = L"MMM d, yyyy";
            break;
        }
 
        // First call to get required size
        int requiredSize = GetDateFormatEx(
            nullptr, flags, &st, customFormat, nullptr, 0, nullptr);
 
        if (requiredSize == 0) {
            throw std::system_error(GetLastError(), std::system_category());
        }
 
        // Allocate WCHAR buffer with exact required size
        std::wstring wbuf(requiredSize, L'\0');
 
        // Second call to actually format
        int result = GetDateFormatEx(
            nullptr, flags, &st, customFormat, wbuf.data(), requiredSize, nullptr);
 
        if (result == 0) {
            throw std::system_error(GetLastError(), std::system_category());
        }
 
        // Convert WCHAR (UTF-16) to UTF-8
        int utf8len = WideCharToMultiByte(CP_UTF8, 0, wbuf.c_str(), -1, nullptr, 0, nullptr, nullptr);
        std::string output(utf8len, '\0');
        WideCharToMultiByte(CP_UTF8, 0, wbuf.c_str(), -1, &output[0], utf8len, nullptr, nullptr);
        output.resize(utf8len - 1); // remove null terminator
 
        return output;
    }
#endif // MUSX_RUNNING_ON_WINDOWS
 
#ifndef MUSX_RUNNING_ON_WINDOWS
    inline static std::string formatDate(std::time_t t, DateFormat style)
    {
        struct tm tm;
 
        localtime_r(&t, &tm);
 
        const char* fmt = nullptr;
        switch (style) {
        case DateFormat::Short:
            fmt = "%x";
            break;
        case DateFormat::Long:
            fmt = "%B %d, %Y";
            break;
        case DateFormat::Abbrev:
            fmt = "%b %d, %Y";
            break;
        }
 
        std::ostringstream oss;
        try {
            oss.imbue(std::locale("")); // Use user’s current locale
        } catch (const std::runtime_error&) {
            oss.imbue(std::locale::classic());
        }
 
        oss << std::put_time(&tm, fmt);
        return oss.str();
    }
#endif // !MUSX_RUNNING_ON_WINDOWS
 
    inline static std::string formatTime(std::time_t t, bool includeSeconds)
    {
#ifdef MUSX_RUNNING_ON_WINDOWS
        SYSTEMTIME st;
        {
            struct tm tm;
            localtime_s(&tm, &t);
            st.wYear = WORD(tm.tm_year + 1900);
            st.wMonth = WORD(tm.tm_mon + 1);
            st.wDay = WORD(tm.tm_mday);
            st.wHour = WORD(tm.tm_hour);
            st.wMinute = WORD(tm.tm_min);
            st.wSecond = WORD(tm.tm_sec);
            st.wMilliseconds = 0;
        }
 
        DWORD flags = 0;
        if (!includeSeconds) {
            flags = TIME_NOSECONDS;
        }
 
        // First call to get required size
        int requiredSize = GetTimeFormatEx(
            nullptr, flags, &st, nullptr, nullptr, 0);
 
        if (requiredSize == 0) {
            throw std::system_error(GetLastError(), std::system_category());
        }
 
        // Allocate WCHAR buffer
        std::wstring wbuf(requiredSize, L'\0');
 
        // Second call to actually format
        int result = GetTimeFormatEx(
            nullptr, flags, &st, nullptr, wbuf.data(), requiredSize);
 
        if (result == 0) {
            throw std::system_error(GetLastError(), std::system_category());
        }
 
        // Convert WCHAR (UTF-16) to UTF-8
        int utf8len = WideCharToMultiByte(CP_UTF8, 0, wbuf.c_str(), -1, nullptr, 0, nullptr, nullptr);
        std::string output(utf8len, '\0');
        WideCharToMultiByte(CP_UTF8, 0, wbuf.c_str(), -1, &output[0], utf8len, nullptr, nullptr);
        output.resize(utf8len - 1); // remove null terminator
 
        return output;
 
#else // POSIX
 
        struct tm tm;
        localtime_r(&t, &tm);
 
        const char* fmt = nullptr;
 
        if (includeSeconds) {
            fmt = "%X"; // Locale-specific full time with seconds
        } else {
            // Determine 24h vs 12h heuristic using nl_langinfo
            bool is24h = false;
            const char* tfmt = nl_langinfo(T_FMT);
            if (tfmt && std::strchr(tfmt, 'H')) {
                is24h = true;
            }
 
            fmt = is24h ? "%H:%M" : "%I:%M %p";
        }
 
        std::ostringstream oss;
        try {
            oss.imbue(std::locale("")); // Use user's current locale
        } catch (const std::runtime_error&) {
            oss.imbue(std::locale::classic());
        }
        oss << std::put_time(&tm, fmt);
        return oss.str();
 
#endif
    }
 
};
 
} // namespace util
} // namespace musx