symbols.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 <array>
#include <cstddef>
#include <cstdint>
#include <string>
#include <string_view>
#include <utility>
#include <vector>

namespace steppable::prettyPrint
{
    using namespace __internals::utils;

    struct Position
    {
        long long x = 0;
        long long y = 0;
    };
 
    // // Not currently in use.
    // enum PrintingAlignment
    // {
    //     BASELINE = 0,
    //     MIDDLE = 1
    // };
 
    // struct PrintingObj
    // {
    //     std::string str;
    //     PrintingAlignment alignment;
    // };
 
    enum class HorizontalAlignment : std::uint8_t
    {
        LEFT = 0,
        CENTER = 1,
        RIGHT = 2
    };

    class ConsoleOutput
    {
    private:
        Position curPos;

        std::vector<std::vector<std::string>> buffer;

        size_t height = 10;

        size_t width = 10;

        void _write(const std::string& s,
                    const Position& pos,
                    bool updatePos = false,
                    const ColorFunc& color = colors::keepOriginal,
                    const HorizontalAlignment& alignment = HorizontalAlignment::LEFT);
 
    public:
        ConsoleOutput(size_t height, size_t width);

        void write(char c,
                   long long dLine,
                   long long dCol,
                   bool updatePos = false,
                   const ColorFunc& color = colors::keepOriginal,
                   const HorizontalAlignment& alignment = HorizontalAlignment::LEFT);

        void write(char c,
                   const Position& pos,
                   bool updatePos = false,
                   const ColorFunc& color = colors::keepOriginal,
                   const HorizontalAlignment& alignment = HorizontalAlignment::LEFT);

        void write(const std::string_view& s,
                   const Position& pos,
                   bool updatePos = false,
                   const ColorFunc& color = colors::keepOriginal,
                   const HorizontalAlignment& alignment = HorizontalAlignment::LEFT)
        {
            _write(static_cast<std::string>(s), pos, updatePos, color, alignment);
        }

        [[nodiscard]] std::string asString() const;
    };

    size_t getStringWidth(const std::string& s);

    size_t getStringHeight(const std::string& s);
} // namespace steppable::prettyPrint
 
namespace steppable::__internals::stringUtils
{

    bool isZeroWidthCharacter(uint32_t codepoint);

    uint32_t getCodepoint(const std::string& str, size_t& i);

    size_t getUnicodeDisplayWidth(const std::string& utf8Str);
 
    bool utf8Decode(const std::string& s, size_t& i, uint32_t& cp);
 
    bool isEmojiBase(uint32_t cp);
 
    bool isClusterExtender(uint32_t cp);
 
    class GraphemeIterator
    {
    public:
        GraphemeIterator(std::string s) : str(std::move(s)) {}
 
        // Returns false when there are no more clusters
        bool next(std::string& cluster)
        {
            if (pos >= str.size())
                return false;
            size_t start = pos;
            uint32_t cp = 0;
            size_t temp = pos;
            if (!utf8Decode(str, temp, cp))
                return false;
 
            // For emoji: group sequences with ZWJ or skin tone
            if (isEmojiBase(cp) || (cp >= 0x1F1E6 && cp <= 0x1F1FF))
            {
                pos = temp;
                while (true)
                {
                    size_t save = pos;
                    uint32_t nextcp = 0;
                    if (!utf8Decode(str, save, nextcp))
                        break;
                    if (isClusterExtender(nextcp) ||
                        // For flags: two regional indicators
                        ((cp >= 0x1F1E6 && cp <= 0x1F1FF) && (nextcp >= 0x1F1E6 && nextcp <= 0x1F1FF)))
                    {
                        pos = save;
                    }
                    else
                    {
                        break;
                    }
                }
                cluster = str.substr(start, pos - start);
                return true;
            }
 
            // For combining marks: group base + following combining
            pos = temp;
            while (true)
            {
                size_t save = pos;
                uint32_t nextcp = 0;
                if (!utf8Decode(str, save, nextcp))
                    break;
                if (isZeroWidthCharacter(nextcp))
                    pos = save;
                else
                    break;
            }
            cluster = str.substr(start, pos - start);
            return true;
        }
 
    private:
        std::string str;
        size_t pos{};
    };
} // namespace steppable::__internals::stringUtils

namespace steppable::__internals::symbols
{
    constexpr std::string_view BECAUSE = "\u2235";
    constexpr std::string_view THEREFORE = "\u2234";

    constexpr std::string_view MULTIPLY = "\u00D7";
    constexpr std::string_view DIVIDED_BY = "\u00F7";
 
    constexpr std::string_view SURD = "\u221A";
    constexpr std::string_view COMBINE_MACRON = "\u0305";

    constexpr std::string_view LARGE_DOT = "\u25C9";
    constexpr std::string_view ABOVE_DOT = "\u02D9";
 
    // Subscripts
    constexpr std::string_view SUB_0 = "\u2080";
    constexpr std::string_view SUB_Z = "\u1D69";
    constexpr int SUB_MAGIC_NUMBER = 8272;

    extern const std::array<std::string, 10>& SUPERSCRIPTS;

    std::string makeSubscript(const std::string& normal);

    std::string makeSubscript(int normal);
 
    // Superscripts
    constexpr std::string_view SUP_0 = "\u2070";
    constexpr std::string_view SUP_Z = "\u1DBB";
    constexpr int SUP_MAGIC_NUMBER = 8304;

    std::string makeSuperscript(const std::string& normal);

    std::string makeSuperscript(char normal);

    std::string makeSurd(const std::string& radicand);

    namespace BoxDrawing
    {
        constexpr std::string_view DOTTED_VERTICAL = "\u2575"; 
        constexpr std::string_view DOTTED_HORIZONTAL = "\u2574"; 
 
        constexpr std::string_view HORIZONTAL = "\u2500"; 
        constexpr std::string_view VERTICAL = "\u2502"; 
 
        // region CONNECTORS
        constexpr std::string_view HORIZONTAL_UP = "\u2534";

        constexpr std::string_view VERTICAL_LEFT = "\u2524";
        // endregion
 
        // region CORNERS
        constexpr std::string_view BOTTOM_RIGHT_CORNER = "\u2518"; 
        // endregion
 
        constexpr std::string_view CROSS = "\u253C"; 
    } // namespace BoxDrawing
} // namespace steppable::__internals::symbols

namespace steppable::prettyPrint::printers
{
    std::string ppRoot(const std::string& radicand, const std::string& index = "2");

    std::string ppFraction(const std::string& top, const std::string& bottom, bool inLine = false);

    std::string ppSubscript(const std::string& base, const std::string& subscript);

    std::string ppSuperscript(const std::string& base, const std::string& superscript);
} // namespace steppable::prettyPrint::printers