text_formatter.hpp

Go to the documentation of this file.

#pragma once
 
#include <cstdint>
#include <format>
#include <functional>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>
 
#include "porytiles/utilities/panic/panic.hpp"
 
namespace porytiles {
 
enum class PredefinedColor : std::uint8_t {
    none,    
    black,   
    red,     
    green,   
    yellow,  
    blue,    
    magenta, 
    cyan,    
    white    
};
 
struct RgbColor {
    std::uint8_t r; 
    std::uint8_t g; 
    std::uint8_t b; 
};
 
class Style {
  public:
    // Formatting constants
    static const Style none;      
    static const Style bold;      
    static const Style faint;     
    static const Style italic;    
    static const Style underline; 
    static const Style blink;     
 
    // Foreground color constants
    static const Style black;   
    static const Style red;     
    static const Style green;   
    static const Style yellow;  
    static const Style blue;    
    static const Style magenta; 
    static const Style cyan;    
    static const Style white;   
 
    // Background color constants
    static const Style bg_black;   
    static const Style bg_red;     
    static const Style bg_green;   
    static const Style bg_yellow;  
    static const Style bg_blue;    
    static const Style bg_magenta; 
    static const Style bg_cyan;    
    static const Style bg_white;   
 
    constexpr Style() = default;
 
    [[nodiscard]] constexpr Style operator|(const Style &other) const
    {
        Style result{};
 
        // Combine format flags with bitwise OR
        result.format_flags_ = format_flags_ | other.format_flags_;
 
        // Foreground color: right-hand side wins if both have foreground colors
        if (other.has_fg_color()) {
            result.fg_predefined_ = other.fg_predefined_;
            result.fg_rgb_ = other.fg_rgb_;
            result.has_fg_rgb_ = other.has_fg_rgb_;
        }
        else if (has_fg_color()) {
            result.fg_predefined_ = fg_predefined_;
            result.fg_rgb_ = fg_rgb_;
            result.has_fg_rgb_ = has_fg_rgb_;
        }
 
        // Background color: right-hand side wins if both have background colors
        if (other.has_bg_color()) {
            result.bg_predefined_ = other.bg_predefined_;
            result.bg_rgb_ = other.bg_rgb_;
            result.has_bg_rgb_ = other.has_bg_rgb_;
        }
        else if (has_bg_color()) {
            result.bg_predefined_ = bg_predefined_;
            result.bg_rgb_ = bg_rgb_;
            result.has_bg_rgb_ = has_bg_rgb_;
        }
 
        return result;
    }
 
    [[nodiscard]] constexpr bool has_bold() const
    {
        return (format_flags_ & bold_flag) != 0;
    }
 
    [[nodiscard]] constexpr bool has_faint() const
    {
        return (format_flags_ & faint_flag) != 0;
    }
 
    [[nodiscard]] constexpr bool has_italic() const
    {
        return (format_flags_ & italic_flag) != 0;
    }
 
    [[nodiscard]] constexpr bool has_underline() const
    {
        return (format_flags_ & underline_flag) != 0;
    }
 
    [[nodiscard]] constexpr bool has_blink() const
    {
        return (format_flags_ & blink_flag) != 0;
    }
 
    [[nodiscard]] constexpr bool has_fg_color() const
    {
        return has_fg_rgb_ || fg_predefined_ != PredefinedColor::none;
    }
 
    [[nodiscard]] constexpr bool has_bg_color() const
    {
        return has_bg_rgb_ || bg_predefined_ != PredefinedColor::none;
    }
 
    [[nodiscard]] constexpr bool is_fg_rgb() const
    {
        return has_fg_rgb_;
    }
 
    [[nodiscard]] constexpr bool is_bg_rgb() const
    {
        return has_bg_rgb_;
    }
 
    [[nodiscard]] constexpr RgbColor fg_rgb() const
    {
        return fg_rgb_;
    }
 
    [[nodiscard]] constexpr RgbColor bg_rgb() const
    {
        return bg_rgb_;
    }
 
    [[nodiscard]] constexpr PredefinedColor fg_predefined() const
    {
        return fg_predefined_;
    }
 
    [[nodiscard]] constexpr PredefinedColor bg_predefined() const
    {
        return bg_predefined_;
    }
 
  private:
    static constexpr std::uint8_t bold_flag = 1 << 0;
    static constexpr std::uint8_t faint_flag = 1 << 1;
    static constexpr std::uint8_t italic_flag = 1 << 2;
    static constexpr std::uint8_t underline_flag = 1 << 3;
    static constexpr std::uint8_t blink_flag = 1 << 4;
 
    std::uint8_t format_flags_{0};
    PredefinedColor fg_predefined_{PredefinedColor::none};
    PredefinedColor bg_predefined_{PredefinedColor::none};
    RgbColor fg_rgb_{0, 0, 0};
    RgbColor bg_rgb_{0, 0, 0};
    bool has_fg_rgb_{false};
    bool has_bg_rgb_{false};
 
    // Private constructors for creating specific style types
    enum class FormatFlagTag { bold, faint, italic, underline, blink };
    enum class FgColorTag { predefined, rgb };
    enum class BgColorTag { predefined, rgb };
 
    constexpr explicit Style(FormatFlagTag tag)
    {
        switch (tag) {
        case FormatFlagTag::bold:
            format_flags_ = bold_flag;
            break;
        case FormatFlagTag::faint:
            format_flags_ = faint_flag;
            break;
        case FormatFlagTag::italic:
            format_flags_ = italic_flag;
            break;
        case FormatFlagTag::underline:
            format_flags_ = underline_flag;
            break;
        case FormatFlagTag::blink:
            format_flags_ = blink_flag;
            break;
        default:
            panic("unhandled FormatFlagTag value");
        }
    }
 
    constexpr explicit Style(FgColorTag, PredefinedColor color) : fg_predefined_{color} {}
 
    constexpr explicit Style(BgColorTag, PredefinedColor color) : bg_predefined_{color} {}
 
    constexpr explicit Style(FgColorTag, std::uint8_t r, std::uint8_t g, std::uint8_t b)
        : fg_rgb_{r, g, b}, has_fg_rgb_{true}
    {
    }
 
    constexpr explicit Style(BgColorTag, std::uint8_t r, std::uint8_t g, std::uint8_t b)
        : bg_rgb_{r, g, b}, has_bg_rgb_{true}
    {
    }
 
    // Friend functions for creating RGB styles
    friend constexpr Style rgb_fg_style(std::uint8_t r, std::uint8_t g, std::uint8_t b);
    friend constexpr Style rgb_bg_style(std::uint8_t r, std::uint8_t g, std::uint8_t b);
};
 
[[nodiscard]] constexpr Style rgb_fg_style(std::uint8_t r, std::uint8_t g, std::uint8_t b)
{
    return Style{Style::FgColorTag::rgb, r, g, b};
}
 
[[nodiscard]] constexpr Style rgb_bg_style(std::uint8_t r, std::uint8_t g, std::uint8_t b)
{
    return Style{Style::BgColorTag::rgb, r, g, b};
}
 
[[nodiscard]] constexpr Style rgb_style(std::uint8_t r, std::uint8_t g, std::uint8_t b)
{
    return rgb_fg_style(r, g, b);
}
 
class FormatParam {
  public:
    FormatParam(std::string text) : text_{std::move(text)}, styles_{Style::none} {}
 
    explicit FormatParam(std::string text, Style styles) : text_{std::move(text)}, styles_{styles} {}
 
    template <typename T>
        requires(
            !std::is_same_v<std::decay_t<T>, std::string> && !std::is_same_v<std::decay_t<T>, FormatParam> &&
            std::formattable<std::decay_t<T>, char>)
    FormatParam(T &&value) : FormatParam(resolve_string(std::forward<T>(value)))
    {
    }
 
    template <typename T>
        requires(
            !std::is_same_v<std::decay_t<T>, std::string> && !std::is_same_v<std::decay_t<T>, FormatParam> &&
            std::formattable<std::decay_t<T>, char>)
    explicit FormatParam(T &&value, Style styles) : FormatParam(resolve_string(std::forward<T>(value)), styles)
    {
    }
 
    [[nodiscard]] const std::string &text() const
    {
        return text_;
    }
 
    [[nodiscard]] Style styles() const
    {
        return styles_;
    }
 
  private:
    std::string text_; 
    Style styles_;     
 
    template <typename T>
    static std::string resolve_string(T &&value)
    {
        return std::format("{}", std::forward<T>(value));
    }
};
 
class TextFormatter {
  public:
    virtual ~TextFormatter() = default;
 
    [[nodiscard]] virtual std::string style(const std::string &text, Style styles) const = 0;
 
    [[nodiscard]] virtual std::string
    format(const std::string &format_str, const std::vector<FormatParam> &params) const;
 
    template <typename FirstParam, typename... RestParams>
        requires(
            !std::is_same_v<std::decay_t<FirstParam>, std::vector<FormatParam>> &&
            std::is_constructible_v<FormatParam, FirstParam> &&
            (std::is_constructible_v<FormatParam, RestParams> && ...))
    [[nodiscard]] std::string format(const std::string &format_str, FirstParam &&first, RestParams &&...rest) const
    {
        std::vector<FormatParam> param_vector;
        param_vector.reserve(1 + sizeof...(RestParams));
        param_vector.emplace_back(std::forward<FirstParam>(first));
        (param_vector.emplace_back(std::forward<RestParams>(rest)), ...);
        return this->format(format_str, param_vector);
    }
};
 
using FormattedMessageBuilder = std::function<std::vector<std::string>(const TextFormatter &)>;
 
} // namespace porytiles