OZWNetwork.h

#pragma once

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

#include <Poco/AtomicCounter.h>
#include <Poco/Mutex.h>
#include <Poco/Path.h>
#include <Poco/Timespan.h>

#include "hotplug/HotplugListener.h"
#include "loop/StoppableLoop.h"
#include "util/EventSource.h"
#include "util/PeriodicRunner.h"
#include "zwave/AbstractZWaveNetwork.h"
#include "zwave/OZWCommand.h"
#include "zwave/ZWaveListener.h"
#include "zwave/ZWaveNode.h"

namespace OpenZWave {

class Notification;
class ValueID;

}

namespace BeeeOn {

class OZWNetwork :
        public HotplugListener,
        public AbstractZWaveNetwork {
        friend class OZWCommand;
public:
        OZWNetwork();
        ~OZWNetwork();

        void setConfigPath(const std::string &path);

        void setUserPath(const std::string &path);

        void setPollInterval(const Poco::Timespan &interval);

        void setIntervalBetweenPolls(bool enable);

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

        void setAssumeAwake(bool awake);

        void setDriverMaxAttempts(int attempts);

        void setNetworkKey(const std::list<std::string> &bytes);

        void setStatisticsInterval(const Poco::Timespan &interval);

        void setControllersToReset(const std::list<std::string> &homes);

        void setExecutor(AsyncExecutor::Ptr executor);

        void registerListener(ZWaveListener::Ptr listener);

        void onNotification(const OpenZWave::Notification *n);

        void onAdd(const HotplugEvent &event) override;

        void onRemove(const HotplugEvent &event) override;

        void configure();

        void cleanup();

protected:
        class OZWNode : public ZWaveNode {
        public:
                OZWNode(const Identity &id, bool controller = false);

                void add(const CommandClass &cc, const OpenZWave::ValueID &id);

                OpenZWave::ValueID operator[](const CommandClass &cc) const;

        private:
                std::map<CommandClass, OpenZWave::ValueID> m_valueIDs;
        };

        void checkDirectory(const Poco::Path &path);

        void prepareDirectory(const Poco::Path &path);

        void fireStatistics();

        static bool matchEvent(const HotplugEvent &event);

        static void ozwNotification(
                OpenZWave::Notification const *n,
                void *context);

        bool ignoreNotification(const OpenZWave::Notification *n) const;

        void resetController(const uint32_t home);

        void driverReady(const OpenZWave::Notification *n);

        void driverFailed(const OpenZWave::Notification *n);

        void driverRemoved(const OpenZWave::Notification *n);

        bool checkNodeIsController(const uint32_t home, const uint8_t node) const;

        void nodeNew(const OpenZWave::Notification *n);

        void nodeAdded(const OpenZWave::Notification *n);

        void nodeNaming(const OpenZWave::Notification *n);

        void nodeProtocolInfo(const OpenZWave::Notification *n);

        void nodeReady(const OpenZWave::Notification *n);

        void nodeRemoved(const OpenZWave::Notification *n);

        void valueAdded(const OpenZWave::Notification *n);

        void valueChanged(const OpenZWave::Notification *n);

        void nodeQueried(const OpenZWave::Notification *n);

        void awakeNodesQueried(const OpenZWave::Notification *n);

        void allNodesQueried(const OpenZWave::Notification *n);

        static std::string homeAsString(uint32_t home);

        static ZWaveNode::CommandClass buildCommandClass(
                        const OpenZWave::ValueID &id);

        void startInclusion() override;

        void cancelInclusion() override;

        void startRemoveNode() override;

        void cancelRemoveNode() override;

        void interrupt() override;

        void postValue(const ZWaveNode::Value &value) override;

        std::string valueForList(const OpenZWave::ValueID &valueID, const int value);

private:
        Poco::Path m_configPath;
        Poco::Path m_userPath;
        Poco::Timespan m_pollInterval;
        bool m_intervalBetweenPolls;
        Poco::Timespan m_retryTimeout;
        bool m_assumeAwake;
        unsigned int m_driverMaxAttempts;
        std::set<uint32_t> m_controllersToReset;
        std::vector<uint8_t> m_networkKey;

        std::map<uint32_t, std::map<uint8_t, OZWNode>> m_homes;

        Poco::AtomicCounter m_configured;

        mutable Poco::FastMutex m_managerLock;

        mutable Poco::FastMutex m_lock;

        OZWCommand m_command;
        EventSource<ZWaveListener> m_eventSource;
        AsyncExecutor::Ptr m_executor;
        PeriodicRunner m_statisticsRunner;
};

}