IQRFDeviceManager.h

#pragma once

#include <set>
#include <string>

#include <Poco/AtomicCounter.h>
#include <Poco/SharedPtr.h>
#include <Poco/Util/Timer.h>

#include "core/DongleDeviceManager.h"
#include "core/PollingKeeper.h"
#include "commands/DeviceAcceptCommand.h"
#include "commands/DeviceUnpairCommand.h"
#include "commands/GatewayListenCommand.h"
#include "iqrf/DPAMessage.h"
#include "iqrf/DPAProtocol.h"
#include "iqrf/IQRFDevice.h"
#include "iqrf/IQRFEventFirer.h"
#include "iqrf/IQRFListener.h"
#include "iqrf/IQRFMqttConnector.h"
#include "model/RefreshTime.h"

namespace BeeeOn {

class IQRFDeviceManager : public DongleDeviceManager {
public:
        IQRFDeviceManager();

        void registerDPAProtocol(DPAProtocol::Ptr protocol);

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

        void setRefreshTime(const Poco::Timespan &refresh);

        void setRefreshTimePeripheralInfo(const Poco::Timespan &refresh);

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

        void setCoordinatorReset(const std::string & reset);

        void setMqttConnector(IQRFMqttConnector::Ptr connector);
        void setDevicePoller(DevicePoller::Ptr poller);

        void setEventsExecutor(AsyncExecutor::Ptr executor);
        void registerListener(IQRFListener::Ptr listener);

        std::string dongleMatch(const HotplugEvent &e) override;
        void dongleAvailable() override;
        void stop() override;

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

        void notifyDongleRemoved() override;
        void dongleFailed(const FailDetector &dongleStatus);

        void eraseAllDevices();


private:
        std::set<uint8_t> obtainBondedNodes(const Poco::Timespan &methodTimeout);
        std::set<uint8_t> obtainNonSynchronizedNodes(
                const std::set<uint8_t> &bondedNodes);

        void syncBondedNodes(const Poco::Timespan &methodTimeout);

        std::string supportedProtocolsToString() const;

        void newDevice(IQRFDevice::Ptr dev);

        DPAProtocol::Ptr detectNodeProtocol(
                DPAMessage::NetworkAddress node,
                const Poco::Timespan &maxMethodTimeout);

        std::map<DeviceID, IQRFDevice::Ptr> obtainDeviceInfo(
                const Poco::Timespan &methodTimeout,
                const std::set<uint8_t> &nodes);

        IQRFDevice::Ptr tryObtainDeviceInfo(
                DPAMessage::NetworkAddress node,
                const Poco::Timespan &methodTimeout);

        IQRFDevice::Ptr bondNewDevice(
                const Poco::Timespan &timeout);

        void coordinatorResetProcess();

private:
        Poco::FastMutex m_lock;
        std::vector<DPAProtocol::Ptr> m_dpaProtocols;
        std::map<DeviceID, IQRFDevice::Ptr> m_devices;
        PollingKeeper m_pollingKeeper;

        IQRFMqttConnector::Ptr m_connector;
        RefreshTime m_refreshTime;
        RefreshTime m_refreshTimePeripheralInfo;
        bool m_coordinatorReset;
        Poco::Timespan m_receiveTimeout;
        Poco::Timespan m_devicesRetryTimeout;
        Poco::AtomicCounter m_bondingMode;

        IQRFEventFirer m_eventFirer;
};

}