VektivaDeviceManager.h

#pragma once

#include <vector>

#include <Poco/Mutex.h>

#include "core/AbstractSeeker.h"
#include "core/DeviceManager.h"
#include "model/DeviceID.h"
#include "net/MqttClient.h"
#include "net/MACAddress.h"
#include "util/BlockingAsyncWork.h"
#include "vektiva/VektivaSmarwi.h"

namespace BeeeOn {

class VektivaDeviceManager : public DeviceManager {
public:

        class VektivaSeeker : public AbstractSeeker {
        public:
                typedef Poco::SharedPtr<VektivaSeeker> Ptr;
                VektivaSeeker(VektivaDeviceManager &parent,
                        const Poco::Timespan &duration);

        protected:

                void seekLoop(StopControl &) override;

        private:
                VektivaDeviceManager &m_parent;
        };

        VektivaDeviceManager();
        void run() override;
        void stop() override;
        void setMqttClient(MqttClient::Ptr mqttClient);
        void setStatusMqttClient(MqttClient::Ptr mqttClient);
        void setReceiveTimeout(const Poco::Timespan &timeout);

protected:
        AsyncWork<>::Ptr startDiscovery(const Poco::Timespan &timeout) override;
        AsyncWork<std::set<DeviceID>>::Ptr startUnpair(
                const DeviceID &id,
                const Poco::Timespan &) override;
        AsyncWork<double>::Ptr startSetValue(
                const DeviceID &id,
                const ModuleID &module,
                const double value,
                const Poco::Timespan &) override;
        void handleAccept(const DeviceAcceptCommand::Ptr cmd) override;

        bool updateDevice(VektivaSmarwi::Ptr newDevice);

        void modifyValue(
                const DeviceID &deviceID,
                const ModuleID &moduleID,
                const double value);

        void statusMessageAction(MqttMessage &mqttMessage);

        void onlineMessageAction(MqttMessage &mqttMessage);

        void clearMqttMessageBuffer();

        void analyzeMessage(MqttMessage &mqttMessage);

        MqttMessage messageReceivedInTime(
                const std::string &lastSegment,
                VektivaSmarwi::Ptr device);

        void shipSmarwiStatus(
                const DeviceID &deviceId,
                const VektivaSmarwiStatus &smarwiStatus);

        void dispatchNewDevice(VektivaSmarwi::Ptr device);

        bool receiveStatusMessageAndUpdate(
                VektivaSmarwi::Ptr device);

        void updateDeviceInfo(
                VektivaSmarwi::Ptr device,
                const VektivaSmarwiStatus &smarwiStatus);

        bool isTopicValid(
                const std::string &topic,
                const std::string &lastSegment,
                const std::string &remoteId = "",
                const std::string &macAddr = "");

        std::pair<std::string, std::string>
        retrieveDeviceInfoFromTopic(const std::string &topic);

        void escapeRegexString(std::string &regexString);

private:
        Poco::FastMutex m_devicesMutex;

        Poco::FastMutex m_clientMqttMutex;

        std::map<DeviceID, VektivaSmarwi::Ptr> m_devices;

        MqttClient::Ptr m_mqttClient;

        MqttClient::Ptr m_mqttStatusClient;
        Poco::Timespan m_receiveTimeout;
};
}