TextField.h

#pragma once

#include <6>
#include <utility>
#include "Constants.h"
#include "Frame.h"
#include "Texture.h"

namespace rose {

    class TextField : public Frame {
    public:
        struct FieldSettings {
            DataType dataType;
            std::string_view id, prefix, suffix;
            int maxLength;
            char eM;
        };

    protected:
        static void enterSettings(std::unique_ptr<rose::Settings> &db, const FieldSettings &setting);

        void saveValue();

        DataType mDataType{DataType::Unset};                
        char mEm{'M'};                                      
        bool mModified{};                                   
        bool mValidEntry{};                                 
        bool mHasFocus{};                                   
        bool mToUpper{};                                    
        int mMaxLength{};                                   
        FontSize mFontSize{};                               
        std::string mFontName{};                            
        FontPointer mFont{};                                
        FontMetrics mFontMetrics{};                         
        color::RGBA mTextColor{};                           
        color::RGBA mErrorColor{};                          
        color::RGBA mUnmodifiedColor{};                     
        std::string mPrefix{};                              
        std::string mSuffix{};                              
        std::string mText{};                                
        std::string::iterator mCaretLoc;                    
        Size mPrefixSize{};                                 
        Size mSuffixSize{};                                 
        Size mTextSize{};                                   
        int mTextMaxGlyph{};                                
        int mGlyphAdvance{};                                

        sdl::Texture mPrefixTexture{};                      
        sdl::Texture mSuffixTexture{};                      
        sdl::Texture mTextTexture{};                        

        std::shared_ptr<std::regex> mValidationPattern{};   
        std::shared_ptr<TextField> mPair{};                 
        Id mPairId{};                                       
        size_t mPairIdx{};                                  

    public:
        TextField() = delete;
        ~TextField() override = default;
        TextField(TextField &&) = delete;
        TextField(const TextField &) = delete;
        TextField& operator=(TextField &&) = delete;
        TextField& operator=(const TextField &) = delete;

        explicit TextField(int maxLength, int padding = 0, FontSize fontSize = 0, const string &fontName = "");

        TextField(int maxLenght, const std::string &text, const std::string &suffix = "", const std::string &prefix = "",
                  int padding = 0, FontSize fontSize = 0, const string &fontName = "");

        explicit TextField(Id id, int padding = 0, FontSize fontSize = 0, const string &fontName = "");

        template<size_t N>
        static void Settings(std::unique_ptr<rose::Settings> &db, const std::array<FieldSettings,N> &settings) {
            for (const auto& setting : settings) {
                enterSettings(db, setting);
            }
        }

        void setPair(const Id &pairId, std::shared_ptr<TextField> &pair);

        Rectangle widgetLayout(sdl::Renderer &renderer, Rectangle available, uint layoutStage) override;

        void draw(sdl::Renderer &renderer, Rectangle parentRect) override;

        void initializeComposite() override;

        void setFontSize(FontSize fontSize) override;

        void setFontName(const std::string &fontName);

        bool textInputEvent(const std::string &text) override;

        bool keyboardFocusEvent(bool focus) override;

        bool keyboardEvent(uint state, uint repeat, SDL_Keysym keysym) override;

        void setRegex(std::shared_ptr<std::regex> regex) {
            mValidationPattern = std::move(regex);
        }

        void setToUpper(bool toUpper) {
            mToUpper = toUpper;
        }

        bool isModified() const { return mModified; }
    };

    struct ToUpperCase {
        bool mToUpperCase{true};
    };
}

template <class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, const std::shared_ptr<std::regex>& regex) {
    static_assert(std::is_base_of_v<rose::TextField,WidgetClass>, "Regex can only be set on TextField Widgets." );
    widget->setRegex(regex);
    return widget;
}

template <class WidgetClass>
inline std::shared_ptr<WidgetClass> operator<<(std::shared_ptr<WidgetClass> widget, const rose::ToUpperCase toUpperCase) {
    static_assert(std::is_base_of_v<rose::TextField,WidgetClass>, "ToUpperCase can only be set on TextField Widgets." );
    widget->setToUpper(toUpperCase.mToUpperCase);
    return widget;
}