Button.h

#pragma once

#include "Constants.h"
#include "Frame.h"
#include "Label.h"
#include "Entypo.h"

namespace rose {

    class ButtonFrame : public Frame {
        friend class RadioBehavior;

    protected:

        SignalSerialNumber mSignalSerialNumber{};   

        ButtonType mButtonType{};                   

        bool mSelectProgress{};                     
        ButtonSetState mButtonSelectState{};        

        bool mouseButtonEvent(const Position &mousePos, int button, bool down, int modifiers) override;

        bool clickTransactionCancel(const Position &mousePos, int button, bool down, int modifiers) override;

        void updateStateSetting(ButtonSetState state);

        std::shared_ptr<Slot<std::string>> mSettingsUpdateRx{};  

    public:
        ButtonFrame() = delete;

        ~ButtonFrame() override = default;

        ButtonFrame(ButtonFrame &&) = delete;

        ButtonFrame(const ButtonFrame &) = delete;

        ButtonFrame &operator=(ButtonFrame &&) = delete;

        ButtonFrame &operator=(const ButtonFrame &) = delete;

        explicit ButtonFrame(int padding = 0) : ButtonFrame(Padding{padding}) {}

        explicit ButtonFrame(Padding padding);

        void initializeComposite() override;

        using SignalType = std::pair<bool, SignalToken>;   

        std::shared_ptr<Slot<SignalType>> rxPushed;

        Signal<SignalType> txPushed;

        std::shared_ptr<Slot<SignalType>> rxState;

        Signal<SignalType> txState;

        void setSelectState(ButtonSetState state) {
            mButtonSelectState = state;
            switch (mButtonType) {
                case NormalButton:
                case CancelButton:
                case MenuCascade:
                case OkButton:
                    setInvert(false);
                    break;
                case ToggleButton:
                case RadioButton:
                case TabButton:
                    setInvert(!state);
                    break;
            }
        }

        ButtonSetState getSelectState() const { return mButtonSelectState; }

        void setStateId(const StateId &stateId) override {
            Widget::setStateId(stateId);
            if ((mButtonType == ButtonType::ToggleButton || mButtonType == ButtonType::RadioButton) &&
                                                           !mStateId.empty() && rose()->hasSettings()) {
                setInvert(rose()->settings()->getValue(mStateId.value(), 0) != 0);
                rose()->settings()->dataChangeTx.connect(mSettingsUpdateRx);

            }
        }
    };

    class Button : public ButtonFrame {
    protected:
        std::string mLabelText{};                   
        ImageId mImageId{RoseImageInvalid};         
        int mLabelFontSize{};                       
        RoseImageId mBadge{RoseImageInvalid};       

    public:
        Button() : ButtonFrame(0) {}

        ~Button() override = default;

        Button(Button &&) = delete;

        Button(const Button &) = delete;

        Button &operator=(Button &&) = delete;

        Button &operator=(const Button &) = delete;

        explicit Button(const std::string &labelString, ButtonType type = ButtonType::NormalButton, int fontSize = 0);

        explicit Button(const Id &id, ButtonType type = ButtonType::NormalButton, int fontSize = 0);

        template<typename String>
        explicit Button(String labelString, ButtonType type = ButtonType::NormalButton)
                : Button(std::string{labelString}, type) {}

        explicit Button(RoseImageId imageId, ButtonType type = ButtonType::NormalButton);

        void initializeComposite() override;

        void setHorizontalAlignment(HorizontalAlignment alignment) override {
            if (auto label = getSingleChild<Label>(); label)
                label->setHorizontalAlignment(alignment);
        }

        void setVerticalAlignment(VerticalAlignment alignment) override {
            if (auto label = getSingleChild<Label>(); label)
                label->setVerticalAlignment(alignment);
        }

        void setText(const std::string &text) override {
            if (auto label = getSingleChild<Label>(); label)
                label->setText(text);
        }

        std::string getText() const {
            if (auto label = getSingleChild<Label>(); label)
                return label->getText();
            return std::string{""};
        }

        void setFontName(std::string &fontName) {
            if (auto label = getSingleChild<Label>(); label)
                label->setFontName(fontName);
        }

        void setFontSize(int fontSize) override {
            if (auto label = getSingleChild<Label>(); label)
                label->setFontSize(fontSize);
        }

        void setImageId(ImageId imageId) override {
            if (auto label = getSingleChild<Label>(); label)
                label->setImageId(imageId);
        }

        void setRenderFlip(sdl::RenderFlip renderFlip) {
            if (auto label = getSingleChild<Label>(); label)
                label->setRenderFlip(renderFlip);
        }

        void setSize(Size size) override;

    };

    class RadioBehavior {
    public:
        enum class State {
            None,
            SetClear,
            Set,
        };

    protected:
        State mState{None};         
        int mSelected{0};           
        bool mNoneIsValid{};        

        using ButtonListType = std::pair<SignalToken,shared_ptr<ButtonFrame>>;
        std::vector<ButtonListType> mButtons{};    

        SignalSerialNumber mSignalSerialNumber{};   

        std::shared_ptr<Slot<ButtonFrame::SignalType>> buttonStateRx{};     

    public:
        using SignalType = std::tuple<State,int,SignalToken>;

        RadioBehavior();

        ~RadioBehavior() = default;

        Signal<SignalType> stateTx{};

        explicit RadioBehavior(bool noneIsValid) : RadioBehavior() { mNoneIsValid = noneIsValid; }

        void emplace_back(std::shared_ptr<ButtonFrame> &button);

        void clear();

        void clearState();

        [[nodiscard]] std::pair<State,int> getState() const {
            return std::make_pair(mState, mSelected);
        }

        void setState(std::pair<State,int> state) {
            setState(state.first, state.second);
        }

        void setState(State state, int selected);
    };
}

inline std::shared_ptr<rose::Button>
operator<<(std::shared_ptr<rose::Button> widget, rose::sdl::RenderFlip &renderFlip) {
    widget->setRenderFlip(renderFlip);
    return widget;
}