DeviceManager.h

#pragma once

#include <set>
#include <typeindex>

#include <Poco/AtomicCounter.h>
#include <Poco/Clock.h>
#include <Poco/Mutex.h>
#include <Poco/SharedPtr.h>

#include "commands/DeviceAcceptCommand.h"
#include "commands/DeviceSetValueCommand.h"
#include "commands/DeviceUnpairCommand.h"
#include "commands/DeviceSearchCommand.h"
#include "commands/GatewayListenCommand.h"
#include "core/AnswerQueue.h"
#include "core/CommandHandler.h"
#include "core/CommandSender.h"
#include "core/DeviceCache.h"
#include "core/DeviceStatusHandler.h"
#include "core/Distributor.h"
#include "loop/StoppableRunnable.h"
#include "loop/StopControl.h"
#include "model/DeviceID.h"
#include "model/DevicePrefix.h"
#include "model/ModuleID.h"
#include "util/AsyncWork.h"
#include "util/CancellableSet.h"
#include "util/Loggable.h"

namespace BeeeOn {

class DeviceManager:
        public CommandHandler,
        public CommandSender,
        public DeviceStatusHandler,
        protected Loggable,
        public StoppableRunnable {
public:
        typedef Poco::SharedPtr<DeviceManager> Ptr;

        DeviceManager(const DevicePrefix &prefix,
                const std::initializer_list<std::type_index> &acceptable = {});
        virtual ~DeviceManager();

        DevicePrefix prefix() const override;

        void stop() override;

        void setDeviceCache(DeviceCache::Ptr cache);
        void setDistributor(Poco::SharedPtr<Distributor> distributor);

        bool accept(const Command::Ptr cmd) override;

        void handle(Command::Ptr cmd, Answer::Ptr answer) override;

        void handleRemoteStatus(
                const DevicePrefix &prefix,
                const std::set<DeviceID> &devices,
                const DeviceStatusHandler::DeviceValues &values) override;

protected:
        std::set<DeviceID> waitRemoteStatus(const Poco::Timespan &timeout);

        virtual void handleGeneric(const Command::Ptr cmd, Result::Ptr result);

        virtual void handleAccept(const DeviceAcceptCommand::Ptr);

        virtual AsyncWork<>::Ptr startDiscovery(const Poco::Timespan &timeout);

        void handleListen(const GatewayListenCommand::Ptr cmd);

        virtual AsyncWork<>::Ptr startSearch(
                const Poco::Timespan &timeout,
                const Poco::Net::IPAddress &address);

        virtual AsyncWork<>::Ptr startSearch(
                const Poco::Timespan &timeout,
                const MACAddress &address);

        virtual AsyncWork<>::Ptr startSearch(
                const Poco::Timespan &timeout,
                const uint64_t serialNumber);

        void handleSearch(const DeviceSearchCommand::Ptr cmd);

        virtual AsyncWork<std::set<DeviceID>>::Ptr startUnpair(
                        const DeviceID &id,
                        const Poco::Timespan &timeout);

        std::set<DeviceID> handleUnpair(const DeviceUnpairCommand::Ptr cmd);

        virtual AsyncWork<double>::Ptr startSetValue(
                        const DeviceID &id,
                        const ModuleID &module,
                        const double value,
                        const Poco::Timespan &timeout);

        AsyncWork<double>::Ptr startSetValueByMode(
                        const DeviceID &id,
                        const ModuleID &module,
                        const double value,
                        const OpMode &mode,
                        const Poco::Timespan &timeout);

        virtual AsyncWork<double>::Ptr startSetValueTryHarder(
                        const DeviceID &id,
                        const ModuleID &module,
                        const double value,
                        const Poco::Timespan &timeout);

        virtual AsyncWork<double>::Ptr startSetValueRepeatOnFail(
                        const DeviceID &id,
                        const ModuleID &module,
                        const double value,
                        const Poco::Timespan &timeout);

        void handleSetValue(const DeviceSetValueCommand::Ptr cmd);

        void ship(const SensorData &sensorData);

        DeviceCache::Ptr deviceCache() const;

        CancellableSet &cancellable();

        Poco::Timespan checkDelayedOperation(
                const std::string &opname,
                const Poco::Clock &started,
                const Poco::Timespan &duration) const;

        bool manageUntilFinished(
                const std::string &opname,
                AnyAsyncWork::Ptr work,
                const Poco::Timespan &timeout);

protected:
        StopControl m_stopControl;

private:
        DevicePrefix m_prefix;
        DeviceCache::Ptr m_deviceCache;
        Poco::FastMutex m_listenLock;
        Poco::FastMutex m_unpairLock;
        Poco::FastMutex m_setValueLock;
        Poco::SharedPtr<Distributor> m_distributor;
        std::set<std::type_index> m_acceptable;
        CancellableSet m_cancellable;
        Poco::AtomicCounter m_remoteStatusDelivered;
};

}