VPTDeviceManager.h

#pragma once

#include <map>
#include <vector>

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

#include "commands/DeviceAcceptCommand.h"
#include "commands/DeviceSetValueCommand.h"
#include "commands/DeviceUnpairCommand.h"
#include "commands/GatewayListenCommand.h"
#include "commands/NewDeviceCommand.h"
#include "core/AbstractSeeker.h"
#include "core/DeviceManager.h"
#include "core/PollingKeeper.h"
#include "core/GatewayInfo.h"
#include "credentials/CredentialsStorage.h"
#include "loop/StopControl.h"
#include "model/DeviceID.h"
#include "model/RefreshTime.h"
#include "util/AsyncWork.h"
#include "util/CryptoConfig.h"
#include "vpt/VPTDevice.h"

namespace BeeeOn {

class VPTDeviceManager : public DeviceManager {
public:
        class VPTSeeker : public AbstractSeeker {
        public:
                typedef Poco::SharedPtr<VPTSeeker> Ptr;

                VPTSeeker(VPTDeviceManager& parent, const Poco::Timespan& duration);

        protected:
                void seekLoop(StopControl &control) override;

        private:
                VPTDeviceManager& m_parent;
        };

        VPTDeviceManager();

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

        void setDevicePoller(DevicePoller::Ptr poller);
        void setRefresh(const Poco::Timespan &refresh);
        void setPingTimeout(const Poco::Timespan &timeout);
        void setHTTPTimeout(const Poco::Timespan &timeout);
        void setMaxMsgSize(int size);
        void setBlackList(const std::list<std::string>& list);
        void setPath(const std::string& path);
        void setPort(const int port);
        void setMinNetMask(const std::string& minNetMask);
        void setGatewayInfo(Poco::SharedPtr<GatewayInfo> gatewayInfo);
        void setCredentialsStorage(Poco::SharedPtr<CredentialsStorage> storage);
        void setCryptoConfig(Poco::SharedPtr<CryptoConfig> config);

protected:
        void handleGeneric(const Command::Ptr cmd, Result::Ptr result) override;
        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 searchPairedDevices();

        bool isAnySubdevicePaired(VPTDevice::Ptr device);

        void modifyValue(const DeviceSetValueCommand::Ptr cmd);

        bool noSubdevicePaired(const DeviceID& id) const;

        std::vector<VPTDevice::Ptr> seekDevices(const StopControl& stop);

        void processNewDevice(Poco::SharedPtr<VPTDevice> newDevice);

        std::string findPassword(const DeviceID& id);

private:
        VPTHTTPScanner m_scanner;
        uint32_t m_maxMsgSize;
        Poco::FastMutex m_pairedMutex;

        PollingKeeper m_pollingKeeper;
        RefreshTime m_refresh;
        Poco::Timespan m_httpTimeout;
        Poco::Timespan m_pingTimeout;

        std::map<DeviceID, VPTDevice::Ptr> m_devices;

        Poco::SharedPtr<GatewayInfo> m_gatewayInfo;
        Poco::SharedPtr<CredentialsStorage> m_credentialsStorage;
        Poco::SharedPtr<CryptoConfig> m_cryptoConfig;
};

}