FHEMClient.h

#pragma once

#include <map>
#include <queue>
#include <string>
#include <vector>

#include <Poco/Event.h>
#include <Poco/Mutex.h>
#include <Poco/SharedPtr.h>
#include <Poco/Timespan.h>
#include <Poco/Timestamp.h>
#include <Poco/Net/DialogSocket.h>
#include <Poco/Net/SocketAddress.h>

#include "conrad/FHEMDeviceInfo.h"
#include "loop/StopControl.h"
#include "loop/StoppableRunnable.h"
#include "util/Loggable.h"

namespace BeeeOn {

class FHEMClient: Loggable, public StoppableRunnable {
public:
        typedef Poco::SharedPtr<FHEMClient> Ptr;

        FHEMClient();

        void setRefreshTime(const Poco::Timespan &time);
        void setReceiveTimeout(const Poco::Timespan &timeout);
        void setReconnectTime(const Poco::Timespan &time);
        void setFHEMAddress(const std::string &address);

        void run() override;
        void stop() override;

        void sendRequest(const std::string& request);

        Poco::JSON::Object::Ptr receive(const Poco::Timespan &timeout);

protected:
        void initConnection();

        void cycle();

        Poco::JSON::Object::Ptr nextEvent();

        void retrieveHomeMaticDevices(std::vector<std::string>& devices);

        void processDevice(const std::string& device);

        FHEMDeviceInfo assembleDeviceInfo(
                const std::string& device,
                const Poco::JSON::Object::Ptr internals) const;

        void retrieveChannelsState(
                Poco::JSON::Object::Ptr internals,
                std::map<std::string, std::string>& channels);

        std::string retrieveChannelState(const std::string& channel);

        void createNewDeviceEvent(
                const std::string& device,
                const std::string& model,
                const std::string& type,
                const std::string& serialNumber);

        void createStatEvent(
                const std::string& event,
                const std::string& device);

        void createMessageEvent(
                const std::string& device,
                const std::string& model,
                const std::string& type,
                const std::string& serialNumber,
                const std::string& rawMsg,
                const double rssi,
                const std::map<std::string, std::string>& channels);

        void appendEventToQueue(const Poco::JSON::Object::Ptr event);

        Poco::JSON::Object::Ptr sendCommand(const std::string& command);

private:
        StopControl m_stopControl;
        Poco::Timespan m_refreshTime;
        Poco::Timespan m_receiveTimeout;
        Poco::Timespan m_reconnectTime;
        Poco::Net::SocketAddress m_fhemAddress;
        Poco::Net::DialogSocket m_telnetSocket;
        std::map<std::string, FHEMDeviceInfo> m_deviceInfos;
        std::queue<Poco::JSON::Object::Ptr> m_eventsQueue;
        Poco::FastMutex m_queueMutex;
        Poco::Event m_receiveEvent;
};

}