ZWaveDeviceManager.h

#pragma once

#include <map>
#include <set>
#include <string>

#include <Poco/Clock.h>
#include <Poco/Mutex.h>
#include <Poco/Timespan.h>

#include "core/DeviceManager.h"
#include "model/RefreshTime.h"
#include "model/SensorValue.h"
#include "util/DelayedAsyncWork.h"
#include "zwave/ZWaveMapperRegistry.h"
#include "zwave/ZWaveNetwork.h"
#include "zwave/ZWaveNode.h"

namespace BeeeOn {

class ZWaveDeviceManager : public DeviceManager {
public:
        class Device {
        public:
                Device(const ZWaveNode &node);

                DeviceID id() const;

                std::string product() const;
                std::string vendor() const;

                void updateNode(const ZWaveNode &node);
                const ZWaveNode &node() const;

                bool resolveMapper(ZWaveMapperRegistry::Ptr registry);

                ZWaveMapperRegistry::Mapper::Ptr mapper() const;

                void setRefresh(const RefreshTime &refresh);
                RefreshTime refresh() const;

                std::list<ModuleType> types() const;

                SensorValue convert(const ZWaveNode::Value &value) const;

                std::string toString() const;

        private:
                ZWaveNode m_node;
                ZWaveMapperRegistry::Mapper::Ptr m_mapper;
                RefreshTime m_refresh;
        };

        typedef std::map<DeviceID, Device> DeviceMap;
        typedef std::map<ZWaveNode::Identity, DeviceMap::iterator> ZWaveNodeMap;

        ZWaveDeviceManager();

        void setNetwork(ZWaveNetwork::Ptr network);

        void setRegistry(ZWaveMapperRegistry::Ptr registry);

        void setDispatchDuration(const Poco::Timespan &duration);

        void setPollTimeout(const Poco::Timespan &timeout);

        void run() override;

        void stop() override;

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

        void dispatchUnpaired();

        void dispatchDevice(const Device &device, bool enabled = true);

        std::set<DeviceID> recentlyUnpaired();

        void processValue(const ZWaveNode::Value &value);

        void newNode(const ZWaveNode &node, bool dispatch);
        void newNodeUnlocked(const ZWaveNode &node, bool dispatch);

        void updateNode(const ZWaveNode &node, bool dispatch);

        void removeNode(const ZWaveNode &node);

        void registerDevice(const Device &device);

        Device unregisterDevice(ZWaveNodeMap::iterator it);

        void stopInclusion();

        void stopRemoveNode();

private:
        ZWaveNetwork::Ptr m_network;
        ZWaveMapperRegistry::Ptr m_registry;
        Poco::Timespan m_dispatchDuration;
        Poco::Timespan m_pollTimeout;

        DeviceMap m_devices;

        ZWaveNodeMap m_zwaveNodes;

        std::set<DeviceID> m_recentlyUnpaired;

        Poco::FastMutex m_lock;

        DelayedAsyncWork<>::Ptr m_inclusionWork;

        DelayedAsyncWork<std::set<DeviceID>>::Ptr m_removeNodeWork;
};

}