Hyperion.h

#pragma once

// stl includes
#include <list>
#include <QMap>

// QT includes
#include <QString>
#include <QStringList>
#include <QSize>
#include <QJsonObject>
#include <QJsonValue>
#include <QJsonArray>
#include <QFileSystemWatcher>
#include <QMutex>

// hyperion-utils includes
#include <utils/Image.h>
#include <utils/ColorRgb.h>
#include <utils/Logger.h>
#include <utils/Components.h>
#include <utils/VideoMode.h>

// Hyperion includes
#include <hyperion/LedString.h>
#include <hyperion/PriorityMuxer.h>
#include <hyperion/ColorAdjustment.h>
#include <hyperion/ComponentRegister.h>

// Effect engine includes
#include <effectengine/EffectDefinition.h>
#include <effectengine/ActiveEffectDefinition.h>
#include <effectengine/EffectSchema.h>

// settings utils
#include <utils/settings.h>

// Forward class declaration
class QTimer;
class HyperionDaemon;
class ImageProcessor;
class MessageForwarder;
class LinearColorSmoothing;
class EffectEngine;
class MultiColorAdjustment;
class ColorAdjustment;
class SettingsManager;
class BGEffectHandler;
class CaptureCont;
class BoblightServer;
class LedDeviceWrapper;

class Hyperion : public QObject
{
    Q_OBJECT
public:
    typedef PriorityMuxer::InputInfo InputInfo;
    enum RgbChannel
    {
        BLACK, WHITE, RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW, INVALID
    };

    ~Hyperion();

    void freeObjects(bool emitCloseSignal=false);

    static Hyperion* initInstance(HyperionDaemon* daemon, const quint8& instance, const QString configFile, const QString rootPath);

    static Hyperion* getInstance();

    EffectEngine* getEffectEngineInstance() { return _effectEngine; };

    PriorityMuxer* getMuxerInstance() { return &_muxer; };

    ImageProcessor* getImageProcessor() { return _imageProcessor; };

    QJsonDocument getSetting(const settings::type& type);

    bool saveSettings(QJsonObject config, const bool& correct = false);

    unsigned getLedCount() const;

    QSize getLedGridSize() const { return _ledGridSize; };

    int getCurrentPriority() const;

    bool isCurrentPriority(const int priority) const;

    QList<int> getActivePriorities() const;

    const InputInfo getPriorityInfo(const int priority) const;

    bool saveEffect(const QJsonObject& obj, QString& resultMsg);

    bool deleteEffect(const QString& effectName, QString& resultMsg);

    const std::list<EffectDefinition> &getEffects() const;

    const std::list<ActiveEffectDefinition> &getActiveEffects();

    const std::list<EffectSchema> &getEffectSchemas();

    const QJsonObject& getQJsonConfig();

    QString getConfigFilePath() { return _configFile; };

    QString getConfigFileName() const;

    void registerInput(const int priority, const hyperion::Components& component, const QString& origin = "System", const QString& owner = "", unsigned smooth_cfg = 0);


    void setSourceAutoSelectEnabled(bool enabled);

    bool setCurrentSourcePriority(int priority );

    bool sourceAutoSelectEnabled();

    void setNewComponentState(const hyperion::Components& component, const bool& state);

    void setComponentState(const hyperion::Components component, const bool state);

    ComponentRegister& getComponentRegister() { return _componentRegister; };

    bool configModified() { return _configMod; };

    bool configWriteable() { return _configWrite; };

    const int & getLedMappingType();

    const QString &getRootPath() { return _rootPath; };

    const QString &getId(){ return _id; };
    void setId(QString id){ _id = id; };

    int getLatchTime() const;

    unsigned addSmoothingConfig(int settlingTime_ms, double ledUpdateFrequency_hz=25.0, unsigned updateDelay=0);

    const VideoMode & getCurrentVideoMode();

    const QString & getActiveDevice();

public slots:
    bool setInput(const int priority, const std::vector<ColorRgb>& ledColors, const int timeout_ms = -1, const bool& clearEffect = true);

    bool setInputImage(const int priority, const Image<ColorRgb>& image, int64_t timeout_ms = -1, const bool& clearEffect = true);

    bool setInputInactive(const quint8& priority);

    void setColor(int priority, const ColorRgb &ledColor, const int timeout_ms = -1, const QString& origin = "System" ,bool clearEffects = true);

    const QStringList & getAdjustmentIds() const;

    ColorAdjustment * getAdjustment(const QString& id);

    void adjustmentsUpdated();

    bool clear(int priority);

    void clearall(bool forceClearAll=false);

    int setEffect(const QString & effectName, int priority, int timeout = -1, const QString & origin="System");

    int setEffect(const QString &effectName
                , const QJsonObject &args
                , int priority
                , int timeout = -1
                , const QString &pythonScript = ""
                , const QString &origin="System"
                , const QString &imageData = ""
    );

    void setLedMappingType(const int& mappingType);

    void setVideoMode(const VideoMode& mode);

public:
    static Hyperion *_hyperion;

signals:
    void channelCleared(int priority);

    void allChannelsCleared();

    void componentStateChanged(const hyperion::Components component, bool enabled);

    void imageToLedsMappingChanged(const int& mappingType);

    void currentImage(const Image<ColorRgb> & image);

    void closing();

    void forwardJsonMessage(QJsonObject);

    void forwardSystemProtoMessage(const QString, const Image<ColorRgb>);

    void forwardV4lProtoMessage(const QString, const Image<ColorRgb>);

    void videoMode(const VideoMode& mode);

    void newVideoMode(const VideoMode& mode);

    void settingsChanged(const settings::type& type, const QJsonDocument& data);

    void adjustmentChanged();

    void effectListUpdated();

    void ledDeviceData(const std::vector<ColorRgb>& ledValues);

    void rawLedColors(const std::vector<ColorRgb>& ledValues);

private slots:
    void update();

    void checkConfigState(QString cfile = NULL);

    void updatedComponentState(const hyperion::Components comp, const bool state);

    void handleSettingsUpdate(const settings::type& type, const QJsonDocument& config);

private:

    Hyperion(HyperionDaemon* daemon, const quint8& instance, const QString configFile, const QString rootPath);

    HyperionDaemon* _daemon;

    SettingsManager* _settingsManager;

    ComponentRegister _componentRegister;

    LedString _ledString;

    LedString _ledStringClone;

    ImageProcessor* _imageProcessor;

    std::vector<ColorOrder> _ledStringColorOrder;

    PriorityMuxer _muxer;

    MultiColorAdjustment * _raw2ledAdjustment;

    LedDeviceWrapper* _ledDeviceWrapper;

    LinearColorSmoothing * _deviceSmooth;

    EffectEngine * _effectEngine;

    // Message forwarder
    MessageForwarder * _messageForwarder;

    QString _configFile;

    QString _rootPath;

    QString _id;

    Logger * _log;

    unsigned _hwLedCount;

    QByteArray _configHash;

    QSize _ledGridSize;

    hyperion::Components   _prevCompId;

    QFileSystemWatcher _fsWatcher;
    QTimer* _cTimer;

    bool _prevConfigMod = false;
    bool _prevConfigWrite = true;

    bool _configMod = false;
    bool _configWrite = true;

    BGEffectHandler* _BGEffectHandler;
    CaptureCont* _captureCont;

    std::vector<ColorRgb> _ledBuffer;

    BoblightServer* _boblightServer;

    QMutex _changes;
};