util.hpp

/**************************************************************************************************
 * Copyright (c) 2023-2025 NWSOFT                                                                 *
 *                                                                                                *
 * 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 "colors.hpp"
#include "output.hpp"
#include "platform.hpp"
 
#include <algorithm>
#include <array>
#include <chrono>
#include <clocale>
#include <cstddef>
#include <iomanip>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
 
using namespace std::literals;
 
#ifndef TIC
    #define TIC(...)                                                                                  \
        {                                                                                             \
            const char* nameSection = #__VA_ARGS__;                                                   \
            std::cout << colors::brightBlue << std::setw(80) << std::setfill('-') << reset << '\n';   \
            std::cout << colors::brightBlue << "[Profiling: " << nameSection << ']' << reset << '\n'; \
            auto start = std::chrono::high_resolution_clock::now();
#endif
 
#ifndef TOC
    #define TOC()                                                                                                     \
        auto duration =                                                                                               \
            std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - start)  \
                .count();                                                                                             \
        std::cout << colors::brightBlue << '[' << nameSection << " took " << duration << "(microseconds) to execute]" \
                  << reset << '\n';                                                                                   \
        std::cout << colors::brightBlue << std::setw(80) << std::setfill('-');                                        \
        std::cout << reset << '\n';                                                                                   \
        }
#endif
 
#ifndef MAX_DECIMALS
    #define MAX_DECIMALS 50
#endif
 
namespace steppable::__internals::utils
{
#ifndef MS_STDLIB_BUGS
    #if (_MSC_VER || __MINGW32__ || __MSVCRT__)
        #define MS_STDLIB_BUGS 1
    #else
        #define MS_STDLIB_BUGS 0 // NOLINT(cppcoreguidelines-macro-usage)
    #endif
#endif
 
#if MS_STDLIB_BUGS
    #include <fcntl.h>
    #include <io.h>
#endif
 
#ifdef WINDOWS
    #include <fcntl.h>
    #include <windows.h>

    inline DWORD enableVtMode()
    {
        // Set output mode to handle virtual terminal sequences
        const HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
        if (hOut == INVALID_HANDLE_VALUE)
            return -1;
 
        DWORD dwMode = 0;
        if (!GetConsoleMode(hOut, &dwMode))
            return -1;
        const DWORD dwModeOrig = dwMode;
 
        dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
        if (!SetConsoleMode(hOut, dwMode))
            return -1;
        return dwModeOrig;
    }

    inline bool restoreVtMode(const DWORD dwModeOrig)
    {
        const HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
        if (hOut == INVALID_HANDLE_VALUE)
            return false;
 
        if (!SetConsoleMode(hOut, dwModeOrig))
            return false;
        return true;
    }

    class Utf8CodePage
    {
    public:
        Utf8CodePage() : oldCodePage(GetConsoleOutputCP())
        {
            SetConsoleOutputCP(CP_UTF8);
            dwModeOrig = enableVtMode();
        }

        ~Utf8CodePage()
        {
            SetConsoleOutputCP(oldCodePage);
            restoreVtMode(dwModeOrig);
        }
 
    private:
        UINT oldCodePage; 
        DWORD dwModeOrig; 
    };
#else

    class Utf8CodePage
    {
    public:
        Utf8CodePage() { ; }
    };
#endif

    template<typename NumberT>
    void checkDecimalArg(const NumberT* decimal)
    {
        if (*decimal > MAX_DECIMALS)
        {
            output::error("checkDecimalArg"s,
                          "The number of decimals ({0}) is more than the accepted {1} digits."s,
                          { std::to_string(*decimal), std::to_string(MAX_DECIMALS) });
            programSafeExit(1);
        }
    }

    template<size_t N>
    struct StringLiteral
    {
        constexpr StringLiteral(const char (&str)[N]) // NOLINT(*-pro-type-member-init, *-explicit-constructor)
        { // NOLINT(*-avoid-c-arrays)
            std::copy_n(str, N, value);
        }

        char value[N]; // NOLINT(*-avoid-c-arrays)
    };
} // namespace steppable::__internals::utils

namespace steppable::__internals::numUtils
{
    struct SplitNumberResult
    {
        std::array<std::string, 4> splitNumberArray;
        bool aIsNegative = false, bIsNegative = false;
    };

    std::string simplifyZeroPolarity(const std::string& string);

    std::string simplifyPolarity(const std::string& _string);

    std::string standardizeNumber(const std::string& _number);

    constexpr bool isZeroString(const std::string& string)
    {
        return std::ranges::all_of(string, [](const char c) { return c == '0' or c == '.' or c == '-'; });
    }

    bool isNumber(const std::string& s);

    SplitNumberResult splitNumber(const std::string& a,
                                  const std::string& b,
                                  bool padInteger = true,
                                  bool padDecimal = true,
                                  bool properlyFormat = true,
                                  bool preserveNegative = false);

    auto replaceLeadingZeros(const std::vector<int>& vector) -> std::decay_t<decltype(vector)>;

    auto removeLeadingZeros(const std::vector<int>& vector) -> std::decay_t<decltype(vector)>;

    auto removeLeadingZeros(const std::string& string) -> std::decay_t<decltype(string)>;

    auto removeTrailingZeros(const std::vector<int>& _vector) -> std::decay_t<decltype(_vector)>;

    auto removeTrailingZeros(const std::string& numStr) -> std::decay_t<decltype(numStr)>;

    long long determineScale(const std::string& number);

    bool isInteger(const std::string& number);

    bool isDecimal(const std::string& number);

    bool isPowerOfTen(const std::string& number);

    bool isOdd(const std::string& number);

    bool isEven(const std::string& number);
} // namespace steppable::__internals::numUtils

namespace steppable::__internals::stringUtils
{
    template<typename CharT>
    auto split(std::basic_string<CharT> s, const CharT separator)
    {
        std::vector<decltype(s)> substrings;
        std::basic_stringstream<CharT> ss(s);
        decltype(s) token;
 
        while (getline(ss, token, separator))
            substrings.push_back(token);
 
        return substrings;
    }

    template<typename CharT>
    auto split(std::basic_string_view<CharT> s, const CharT separator)
    {
        std::vector<decltype(s)> result;
        auto left = s.begin();
        for (auto it = left; it != s.end(); ++it)
        {
            if (*it == separator)
            {
                result.emplace_back(&*left, it - left);
                left = it + 1;
            }
        }
        if (left != s.end())
            result.emplace_back(&*left, s.end() - left);
        return result;
    }

    template<typename CharT>
    auto rReplace(const std::basic_string<CharT> s, const CharT t, const CharT replacement = '\0')
    {
        std::basic_string<CharT> out = s;
        typename std::basic_string<CharT>::size_type count = 0;
        while (out.back() == t)
        {
            out.pop_back();
            ++count;
        }
        if (replacement != '\0')
            out += std::basic_string<CharT>(count, replacement);
        return out;
    }

    template<typename CharT>
    auto lReplace(const std::basic_string<CharT> s, const CharT t, const CharT replacement = '\0')
    {
        std::basic_string<CharT> out = s;
        typename std::basic_string<CharT>::size_type count = 0;
        while (out[0] == t)
        {
            out.erase(out.begin());
            ++count;
        }
        if (replacement != '\0')
            out = std::basic_string<CharT>(count, replacement) + out;
        return out;
    }

    template<typename CharT>
    auto bothEndsReplace(const std::basic_string<CharT> s, const CharT t, const CharT replacement = '\0')
    {
        return lReplace(rReplace(s, t, replacement), t, replacement);
    }

    template<typename T>
    auto join(const std::vector<T>& vector, const std::string& delimiter)
    {
        std::stringstream result;
        for (const auto& item : vector)
            result << item << delimiter;
        return result.str();
    }

    std::string makeWider(const std::string& orig);

    [[maybe_unused]] int utf8ToUnicode(const std::string& utf8_code);

    std::string unicodeToUtf8(int unicode);

    std::vector<std::string> duplicates(const std::vector<std::string>& vector);
 
    template<typename ValueType>
    std::string vectorToString(const std::vector<ValueType>& vector)
    {
        std::ostringstream out;
        out << "[";
        for (size_t i = 0; i < vector.size(); ++i)
        {
            out << vector[i];
            if (i != vector.size() - 1)
                out << ", ";
        }
        return out.str();
    }
} // namespace steppable::__internals::stringUtils