renderbug/lib/Figments/Input.h

#pragma once
#include <Arduino.h>
#include "./Geometry.h"
#include "./Figment.h"
#include "./Ringbuf.h"
#include <FastLED.h>

typedef Vector3d<int> MotionVec;

struct Variant {
    enum Type {
        Null,
        Integer,
        String,
        Color,
        Pointer,
    };

    Variant(int v)
      : type(Integer), m_value{.asInt=v} {}

    Variant(const char* v)
      : type(String), m_value{.asString=v} {}

    Variant(const CRGB &v)
      : type(Color), m_value{.asRGB={v.r, v.g, v.b}} {}

    Variant(void* p)
      : type(Pointer), m_value{.asPointer=p} {}

    Variant()
      : type(Null) {}

    Type type;

    const char* asString() const;
    CRGB asRGB() const;
    int asInt() const;
    bool asBool() const;
    template<typename T> const T* as() const {
        return static_cast<const T*>(m_value.asPointer);
    }

private:
    union {
        int asInt;
        const char* asString;
        uint8_t asRGB[3];
        void* asPointer;
    } m_value;
};

struct InputEvent: public Variant {
    enum Intent {
        // An empty non-event
        None,

        // System activity
        ReadyToRoll,
        IdleStart,
        IdleStop,

        //
        // The canonical types
        //
        // Hardware inputs
        ButtonPress,
        Acceleration,

        // Network management
        NetworkStatus,
        NetworkActivity,

        // Power management
        PowerToggle,
        SetPower,
        SetBrightness,

        // Animation sequencing
        SetPattern,
        SetScene,

        // Timekeeping
        Beat,
        BeatDetect,

        // Task management
        StartThing,
        StopThing,

        // Configuration
        LoadConfigurationByName,
        SaveConfigurationRequest,
        ConfigurationChanged,
        SetColor,

        // Firmware events
        FirmwareUpdate,
    };

    template<typename Value>
    InputEvent(Intent s, Value v)
      : Variant(v), intent(s) {}

    InputEvent(Intent s)
      : Variant(), intent(s) {}

    InputEvent()
      : Variant(), intent(None) {}

    bool operator!=(const InputEvent::Intent& otherIntent) {
        return intent != otherIntent;
    }

    const char* name() const;

    Intent intent;
};

struct MainLoop;

class InputSource: public Task {
public:
    InputSource() : Task() {init();}
    explicit InputSource(const char* name) : Task(name) {init();}
    void loop() override;
    void onStart() override;
    virtual InputEvent read() = 0;
private:
    void init();
#ifdef CONFIG_THREADED_INPUTS
    static void readThread(void* data);
    MainLoop* m_threadLoop = nullptr;
    static uint8_t m_threadBuf[sizeof(InputEvent) * 32];
    QueueHandle_t m_queue;
    StaticQueue_t m_threadQueue;
#endif
};

class InputFunc : public InputSource {
public:
    InputFunc(std::function<InputEvent(void)> f) : InputSource(), m_func(f) {}
    InputFunc(std::function<InputEvent(void)> f, const char* name) : InputSource(name), m_func(f) {}

    InputEvent read() override {
        return m_func();
    }

private:
    std::function<InputEvent(void)> m_func;
};

class BufferedInputSource: public InputSource {
public:
    BufferedInputSource(const char* name) : InputSource(name) {}
    InputEvent read() override;

protected:
    void setEvent(InputEvent &&evt);
    void setEvent(InputEvent::Intent intent, Variant &&v);

private:
    Ringbuf<InputEvent, 12> m_eventQueue;
};

class InputMapper: public BufferedInputSource {
public:
    InputMapper(std::function<InputEvent(const InputEvent)> f, const char* name) : BufferedInputSource(name), m_func(f) {}

    void handleEvent(const InputEvent& evt) override {
        setEvent(m_func(evt));
    }

private:
    std::function<InputEvent(const InputEvent)> m_func;
};

class OnlineTaskMixin : public virtual Loopable {
  public:
    void handleEvent(const InputEvent &evt) override {
        if (evt.intent == InputEvent::NetworkStatus) {
            m_online = evt.asInt();
            if (m_online) {
              onOnline();
            } else {
              onOffline();
            }
        }
        if (m_online) {
            handleEventOnline(evt);
        }
    }

    virtual void onOnline() {}
    virtual void onOffline() {}

    virtual void handleEventOnline(const InputEvent &evt) {}

    void loop() override {
        if (m_online) {
            loopOnline();
        }
    }

    virtual void loopOnline() {}

  private:
    bool m_online = false;
};