ConradDeviceManager.h

#pragma once

#include <string>

#include <Poco/Timespan.h>
#include <Poco/JSON/Object.h>

#include "core/DeviceManager.h"
#include "conrad/ConradDevice.h"
#include "conrad/ConradListener.h"
#include "conrad/FHEMClient.h"
#include "model/DeviceID.h"
#include "util/AsyncExecutor.h"
#include "util/BlockingAsyncWork.h"
#include "util/EventSource.h"
#include "util/JsonUtil.h"

namespace BeeeOn {

class ConradDeviceManager : public DeviceManager {
public:
        ConradDeviceManager();

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

        void setFHEMClient(FHEMClient::Ptr fhemClient);
        void setEventsExecutor(AsyncExecutor::Ptr executor);

        void registerListener(ConradListener::Ptr listener);

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

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

        void processMessageEvent(
                const DeviceID& deviceID,
                const Poco::JSON::Object::Ptr event);

        void createNewDeviceUnlocked(const DeviceID &deviceID, const std::string &type);

        void fireMessage(DeviceID const &deviceID, const Poco::JSON::Object::Ptr message);

private:
        Poco::FastMutex m_devicesMutex;
        std::map<DeviceID, ConradDevice::Ptr> m_devices;

        FHEMClient::Ptr m_fhemClient;
        EventSource<ConradListener> m_eventSource;
};

}