hyperion.ng/include/hyperion/Hyperion.h

#pragma once

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

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

// 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;

///
/// The main class of Hyperion. This gives other 'users' access to the attached LedDevice through
/// the priority muxer.
///
class Hyperion : public QObject
{
	Q_OBJECT
public:
	///  Type definition of the info structure used by the priority muxer
	typedef PriorityMuxer::InputInfo InputInfo;
	///
	/// RGB-Color channel enumeration
	///
	enum RgbChannel
	{
		BLACK, WHITE, RED, GREEN, BLUE, CYAN, MAGENTA, YELLOW, INVALID
	};

	///
	/// Destructor; cleans up resources
	///
	~Hyperion();

	///
	/// free all alocated objects, should be called only from constructor or before restarting hyperion
	///
	void freeObjects(bool emitCloseSignal=false);

	///
	/// @brief creates a new Hyperion instance, usually called from the Hyperion Daemon
	/// @param[in] daemon        The Hyperion daemon parent
	/// @param[in] instance      The instance id
	/// @param[in] rootPath      Root path of all hyperion userdata
	/// @return                  Hyperion instance pointer
	///
	static Hyperion* initInstance(HyperionDaemon* daemon, const quint8& instance, const QString configFile, const QString rootPath);

	///
	/// @brief Get a pointer of this Hyperion instance
	/// @return    Hyperion instance pointer
	///
	static Hyperion* getInstance();

	///
	/// @brief Get a pointer to the effect engine
	/// @return     EffectEngine instance pointer
	///
	EffectEngine* getEffectEngineInstance() { return _effectEngine; };

	///
	/// @brief Get a pointer to the priorityMuxer instance
	/// @return      PriorityMuxer instance pointer
	///
	PriorityMuxer* getMuxerInstance() { return &_muxer; };

	ImageProcessor* getImageProcessor() { return _imageProcessor; };

	///
	/// @brief Get a setting by settings::type from SettingsManager
	/// @param type  The settingsType from enum
	/// @return      Data Document
	///
	QJsonDocument getSetting(const settings::type& type);

	///
	/// @brief Save a complete json config
	/// @param config  The entire config object
	/// @param correct If true will correct json against schema before save
	/// @return        True on success else false
	///
	bool saveSettings(QJsonObject config, const bool& correct = false);

	///
	/// Returns the number of attached leds
	///
	unsigned getLedCount() const;

	///
	/// @brief Return the size of led grid
	///
	QSize getLedGridSize() const { return _ledGridSize; };

	///
	/// Returns the current priority
	///
	/// @return The current priority
	///
	int getCurrentPriority() const;

	///
	/// Returns true if current priority is given priority
	///
	/// @return bool
	///
	bool isCurrentPriority(const int priority) const;

	///
	/// Returns a list of all registered priorities
	///
	/// @return The list with priorities
	///
	QList<int> getActivePriorities() const;

	///
	/// Returns the information of a specific priorrity channel
	///
	/// @param[in] priority  The priority channel
	///
	/// @return The information of the given, a not found priority will return lowest priority as fallback
	///
	const InputInfo getPriorityInfo(const int priority) const;

	///
	/// @brief Save an effect
	/// @param       obj       The effect args
	/// @param[out] resultMsg  The feedback message
	/// @return True on success else false
	///
	const bool saveEffect(const QJsonObject& obj, QString& resultMsg);

	///
	/// @brief Delete an effect by name.
	/// @param[in]  effectName  The effect name to delete
	/// @param[out] resultMsg   The message on error
	/// @return True on success else false
	///
	const bool deleteEffect(const QString& effectName, QString& resultMsg);

	/// Get the list of available effects
	/// @return The list of available effects
	const std::list<EffectDefinition> &getEffects() const;

	/// Get the list of active effects
	/// @return The list of active effects
	const std::list<ActiveEffectDefinition> &getActiveEffects();

	/// Get the list of available effect schema files
	/// @return The list of available effect schema files
	const std::list<EffectSchema> &getEffectSchemas();

	/// gets the current json config object from SettingsManager
	/// @return json config
	const QJsonObject& getQJsonConfig();

	/// get path+filename of configfile
	/// @return the current config path+filename
	QString getConfigFilePath() { return _configFile; };

	/// get filename of configfile
	/// @return the current config filename
	QString getConfigFileName() const;

	///
	/// @brief  Register a new input by priority, the priority is not active (timeout -100 isn't muxer recognized) until you start to update the data with setInput()
	/// 		A repeated call to update the base data of a known priority won't overwrite their current timeout
	/// @param[in] priority    The priority of the channel
	/// @param[in] component   The component of the channel
	/// @param[in] origin      Who set the channel (CustomString@IP)
	/// @param[in] owner       Specific owner string, might be empty
	/// @param[in] smooth_cfg  The smooth id to use
	///
	void registerInput(const int priority, const hyperion::Components& component, const QString& origin = "System", const QString& owner = "", unsigned smooth_cfg = 0);


	/// enable/disable automatic/priorized source selection
	/// @param enabled the state
	void setSourceAutoSelectEnabled(bool enabled);

	/// set current input source to visible
	/// @param priority the priority channel which should be vidible
	/// @return true if success, false on error
	bool setCurrentSourcePriority(int priority );

	/// gets current state of automatic/priorized source selection
	/// @return the state
	bool sourceAutoSelectEnabled();

	///
	/// @brief Called from components to update their current state. DO NOT CALL FROM USERS
	/// @param[in] component The component from enum
	/// @param[in] state The state of the component [true | false]
	///
	void setNewComponentState(const hyperion::Components& component, const bool& state);

	///
	/// @brief Enable/Disable components during runtime, called from external API (requests)
	///
	/// @param component The component from enum
	/// @param state The state of the component [true | false]
	///
	void setComponentState(const hyperion::Components component, const bool state);

	ComponentRegister& getComponentRegister() { return _componentRegister; };

	bool configModified() { return _configMod; };

	bool configWriteable() { return _configWrite; };

	/// gets the methode how image is maped to leds
	const int & getLedMappingType();

	/// get the root path for all hyperion user data files
	const QString &getRootPath() { return _rootPath; };

	/// get unique id per instance
	const QString &getId(){ return _id; };
	/// set unique id
	void setId(QString id){ _id = id; };

	int getLatchTime() const;

	/// forward smoothing config
	unsigned addSmoothingConfig(int settlingTime_ms, double ledUpdateFrequency_hz=25.0, unsigned updateDelay=0);

	const VideoMode & getCurrentVideoMode();

	///
	/// @brief Get the current active led device
	/// @return The device nam
	/// e
	const QString & getActiveDevice();

public slots:
	///
	/// @brief   Update the current color of a priority (prev registered with registerInput())
	///  		 DO NOT use this together with setInputImage() at the same time!
	/// @param  priority     The priority to update
	/// @param  ledColors    The colors
	/// @param  timeout_ms   The new timeout (defaults to -1 endless)
	/// @param  clearEffect  Should be true when NOT called from an effect
	/// @return              True on success, false when priority is not found
	///
	const bool setInput(const int priority, const std::vector<ColorRgb>& ledColors, const int timeout_ms = -1, const bool& clearEffect = true);

	///
	/// @brief   Update the current image of a priority (prev registered with registerInput())
	/// 		 DO NOT use this together with setInput() at the same time!
	/// @param  priority     The priority to update
	/// @param  image        The new image
	/// @param  timeout_ms   The new timeout (defaults to -1 endless)
	/// @param  clearEffect  Should be true when NOT called from an effect
	/// @return              True on success, false when priority is not found
	///
	const bool setInputImage(const int priority, const Image<ColorRgb>& image, int64_t timeout_ms = -1, const bool& clearEffect = true);

	///
	/// @brief Set the given priority to inactive
	/// @param priority  The priority
	/// @return True on success false if not found
	///
	const bool setInputInactive(const quint8& priority);

	///
	/// Writes a single color to all the leds for the given time and priority
	/// Registers comp color or provided type against muxer
	/// Should be never used to update leds continuous
	///
	/// @param[in] priority The priority of the written color
	/// @param[in] ledColor The color to write to the leds
	/// @param[in] origin   The setter
	/// @param[in] timeout_ms The time the leds are set to the given color [ms]
	///
	void setColor(int priority, const ColorRgb &ledColor, const int timeout_ms = -1, const QString& origin = "System" ,bool clearEffects = true);

	///
	/// Returns the list with unique adjustment identifiers
	/// @return The list with adjustment identifiers
	///
	const QStringList & getAdjustmentIds() const;

	///
	/// Returns the ColorAdjustment with the given identifier
	/// @return The adjustment with the given identifier (or nullptr if the identifier does not exist)
	///
	ColorAdjustment * getAdjustment(const QString& id);

	/// Tell Hyperion that the corrections have changed and the leds need to be updated
	void adjustmentsUpdated();

	///
	/// Clears the given priority channel. This will switch the led-colors to the colors of the next
	/// lower priority channel (or off if no more channels are set)
	///
	/// @param[in] priority  The priority channel
	/// @return              True on success else false (not found)
	///
	const bool clear(int priority);

	///
	/// @brief Clears all priority channels. This will switch the leds off until a new priority is written.
	///
	void clearall(bool forceClearAll=false);

	/// Run the specified effect on the given priority channel and optionally specify a timeout
	/// @param effectName Name of the effec to run
	///	@param priority The priority channel of the effect
	/// @param timeout The timeout of the effect (after the timout, the effect will be cleared)
	int setEffect(const QString & effectName, int priority, int timeout = -1, const QString & origin="System");

	/// Run the specified effect on the given priority channel and optionally specify a timeout
	/// @param effectName Name of the effec to run
	/// @param args arguments of the effect script
	///	@param priority The priority channel of the effect
	/// @param timeout The timeout of the effect (after the timout, the effect will be cleared)
	int setEffect(const QString &effectName
				, const QJsonObject &args
				, int priority
				, int timeout = -1
				, const QString &pythonScript = ""
				, const QString &origin="System"
				, const QString &imageData = ""
	);

	/// sets the methode how image is maped to leds at ImageProcessor
	void setLedMappingType(const int& mappingType);

	///
	/// Set the video mode (2D/3D)
	/// @param[in] mode The new video mode
	///
	void setVideoMode(const VideoMode& mode);

public:
	static Hyperion *_hyperion;

signals:
	/// Signal which is emitted when a priority channel is actively cleared
	/// This signal will not be emitted when a priority channel time out
	void channelCleared(int priority);

	/// Signal which is emitted when all priority channels are actively cleared
	/// This signal will not be emitted when a priority channel time out
	void allChannelsCleared();

	///
	/// @brief Emits whenever a user request a component state change, it's up the component to listen
	/// 	   and update the component state at the componentRegister
	/// @param component  The component from enum
	/// @param enabled    The new state of the component
	///
	void componentStateChanged(const hyperion::Components component, bool enabled);

	///
	/// @brief Emits whenever the imageToLedsMapping has changed
	/// @param mappingType The new mapping type
	///
	void imageToLedsMappingChanged(const int& mappingType);

	///
	/// @brief Emits whenever the visible priority delivers a image which is applied in update()
	/// 	   priorities with ledColors won't emit this signal
	/// @param  image  The current image
	///
	void currentImage(const Image<ColorRgb> & image);

	void closing();

	/// Signal which is emitted, when a new json message should be forwarded
	void forwardJsonMessage(QJsonObject);

	/// Signal which is emitted, when a new proto image should be forwarded
	void forwardProtoMessage(const QString, const Image<ColorRgb>);

	///
	/// @brief Is emitted from clients who request a videoMode change
	///
	void videoMode(const VideoMode& mode);

	///
	/// @brief A new videoMode was requested (called from Daemon!)
	///
	void newVideoMode(const VideoMode& mode);

	///
	/// @brief Emits whenever a config part changed. SIGNAL PIPE helper for SettingsManager -> HyperionDaemon
	/// @param type   The settings type from enum
	/// @param data   The data as QJsonDocument
	///
	void settingsChanged(const settings::type& type, const QJsonDocument& data);

	///
	/// @brief Emits whenever the adjustments have been updated
	///
	void adjustmentChanged();

	///
	/// @brief Signal pipe from EffectEngine to external, emits when effect list has been updated
	///
	void effectListUpdated();

	///
	/// @brief Emits whenever new data should be pushed to the LedDeviceWrapper which forwards it to the threaded LedDevice
	///
	void ledDeviceData(const std::vector<ColorRgb>& ledValues);

	///
	/// @brief Emits whenever new untransformed ledColos data is available, reflects the current visible device
	///
	void rawLedColors(const std::vector<ColorRgb>& ledValues);

private slots:
	///
	/// Updates the priority muxer with the current time and (re)writes the led color with applied
	/// transforms.
	///
	void update();

	/// check for configWriteable and modified changes, called by _fsWatcher or fallback _cTimer
	void checkConfigState(QString cfile = NULL);

	///
	///	@brief Apply ComponentRegister emits for COMP_ALL. Enables/Disables core timers
	///	@param comp   The component
	///	@param state  The new state of the component
	///
	void updatedComponentState(const hyperion::Components comp, const bool state);

	///
	///	@brief Apply settings updates for LEDS and COLOR
	///	@param type   The type from enum
	///	@param config The configuration
	///
	void handleSettingsUpdate(const settings::type& type, const QJsonDocument& config);

private:

	///
	/// Constructs the Hyperion instance based on the given Json configuration
	///
	/// @param[in] qjsonConfig The Json configuration
	///
	Hyperion(HyperionDaemon* daemon, const quint8& instance, const QString configFile, const QString rootPath);

	/// The parent Hyperion Daemon
	HyperionDaemon* _daemon;

	/// Settings manager of this instance
	SettingsManager* _settingsManager;

	/// Register that holds component states
	ComponentRegister _componentRegister;

	/// The specifiation of the led frame construction and picture integration
	LedString _ledString;

	/// specifiation of cloned leds
	LedString _ledStringClone;

	/// Image Processor
	ImageProcessor* _imageProcessor;

	std::vector<ColorOrder> _ledStringColorOrder;

	/// The priority muxer
	PriorityMuxer _muxer;

	/// The adjustment from raw colors to led colors
	MultiColorAdjustment * _raw2ledAdjustment;

	/// The actual LedDeviceWrapper
	LedDeviceWrapper* _ledDeviceWrapper;

	/// The smoothing LedDevice
	LinearColorSmoothing * _deviceSmooth;

	/// Effect engine
	EffectEngine * _effectEngine;

	// Message forwarder
	MessageForwarder * _messageForwarder;

	/// the name of config file
	QString _configFile;

	/// root path for all hyperion user data files
	QString _rootPath;

	/// unique id per instance
	QString _id;

	/// Logger instance
	Logger * _log;

	/// count of hardware leds
	unsigned _hwLedCount;

	QByteArray _configHash;

	QSize _ledGridSize;

	/// Store the previous compID for smarter update()
	hyperion::Components   _prevCompId;

	/// Observe filesystem changes (_configFile), if failed use Timer
	QFileSystemWatcher _fsWatcher;
	QTimer* _cTimer;

	/// holds the prev states of configWriteable and modified
	bool _prevConfigMod = false;
	bool _prevConfigWrite = true;

	/// holds the current states of configWriteable and modified
	bool _configMod = false;
	bool _configWrite = true;

	/// Background effect instance, kept active to react on setting changes
	BGEffectHandler* _BGEffectHandler;
	/// Capture control for Daemon native capture
	CaptureCont* _captureCont;

	// lock Hyperion::update() for exec
	bool _lockUpdate = false;

	/// buffer for leds (with adjustment)
	std::vector<ColorRgb> _ledBuffer;

	/// Boblight instance
	BoblightServer* _boblightServer;
};