Keyboard.h

#pragma once

#include <utility>

#include "Frame.h"
#include "Button.h"
#include "Container.h"

namespace rose {

    enum class KeyboardMode {
        LowerCase,          
        UpperCase,          
        Numbers,            
        Symbols,            
    };

    template<size_t N>
    using KeySpec = std::array<uint32_t,N>;

    template<size_t N>
    constexpr auto makeKeySpec(const char *values) noexcept {
        auto a = KeySpec<N>{};
        const char *cp = values;
        for (auto &v : a) {
            if (*cp != '\0') {
                v = static_cast<uint32_t>(*cp++);
            } else {
                v = 0;
            }
        }
        return a;
    }

    template<class I, typename Arg, typename ... Args>
    constexpr I makeKeySpecInit(I first, I last, Arg arg, Args ... args) noexcept {
        if (first != last) {
            *first = static_cast<uint32_t>(arg);
            ++first;
            if constexpr (sizeof...(args) > 0) {
                first = makeKeySpecInit(first, last, args...);
            }
        }
        return first;
    }

    template<size_t N, typename ... Args>
    constexpr auto makeKeySpec(Args ... args) noexcept {
        auto a = KeySpec<N>{};
        auto first = a.begin();
        auto last = a.end();
        last = makeKeySpecInit(first, last, args...);
        return a;
    }

    template<size_t M, size_t N>
    using KeySpecRow = std::array<KeySpec<N>,M>;

    using KSS = std::array<char,5>;

    template<size_t R, size_t M, size_t N>
    using KeyboardSpec = std::array<std::array<KeySpec<N>,M>,R>;

    class Keyboard;

    class KeyboardPlugin {
    public:
        KeyboardPlugin() = default;
        virtual ~KeyboardPlugin() = default;

        virtual void
        build(shared_ptr <Keyboard> keyboard, Size keySize, int fontSize, const std::string &fontName) = 0;
    };

    class Keyboard : public Frame {
    protected:
        std::shared_ptr<KeyboardPlugin> mKeyboardPlugin{};  

        KeyboardMode mKeyboardMode{KeyboardMode::LowerCase};    

        char mEm{'M'};                          
//        std::shared_ptr<Column> mKeysGrid;      ///< The Column of key rows.
        Size mKeySize{};                        

        std::string mFontName{};                
        int mFontSize{};                        

    public:

        Keyboard() = delete;

        ~Keyboard() override = default;

        Keyboard(Keyboard &&) = delete;

        Keyboard(const Keyboard &) = delete;

        Keyboard &operator=(Keyboard &&) = delete;

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

        explicit Keyboard(std::shared_ptr<KeyboardPlugin> keyboardPlugin) : mKeyboardPlugin(std::move(keyboardPlugin)) {}

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

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

        void initializeComposite() override;
    };

    class QUERTY : public KeyboardPlugin {
    protected:
        static constexpr size_t Rows = 4;
        static constexpr size_t KeysPerRow = 11;
        static constexpr size_t Depth = 4;
        static const KeyboardSpec<Rows, KeysPerRow, Depth> QWERTYData;     

        std::weak_ptr<Keyboard> mKeyboard{};            

        using KeySpecType = KeySpec<Depth>;

        enum class KeyboardMode : size_t  {
            LowerCase, UpperCase, Numeric, Symbols,
        };

        enum class SymbolState : size_t {
            None, Symbols1, Symbols2,
        };

        uint32_t mTempShiftKey{0};    
        bool mCapsLock{false};        

        SymbolState mSymbolState{SymbolState::None};            
        KeyboardMode mKeyboardMode{KeyboardMode::LowerCase};    

        std::shared_ptr<Slot<Button::SignalType>> rxKey{};
        std::shared_ptr<Slot<Button::SignalType>> rxCtl{};
        std::shared_ptr<Slot<Button::SignalType>> rxToggle{};

        auto controlKeyData(const KeySpec<Depth> &keyData);

        void setKeyboardMode();

        void changeKeyboardFace();

    public:
        QUERTY() = default;
        ~QUERTY() override = default;

        void build(shared_ptr <Keyboard> keyboard, Size keySize, int fontSize, const std::string &fontName) override;
    };

    class NumberPad : public KeyboardPlugin {
    protected:
        static constexpr size_t Rows = 5;
        static constexpr size_t KeysPerRow = 3;
        static const KeyboardSpec<Rows, KeysPerRow, 1> NumberData;     

        static constexpr size_t SideCols = 1;
        static constexpr size_t SideKeysPerCol = 5;
        static const KeyboardSpec<SideCols,SideKeysPerCol, 1> SideNumberData;  

        std::shared_ptr<Slot<Button::SignalType>> rxKey{};      

    public:
        NumberPad() = default;
        ~NumberPad() override = default;

        void build(std::shared_ptr<Keyboard> keyboard, Size keySize, int fontSize, const std::string &fontName) override;
    };
}