VPTDevice.h

#pragma once

#include <list>
#include <map>
#include <string>
#include <vector>

#include <Poco/JSON/Object.h>
#include <Poco/Mutex.h>
#include <Poco/Net/HTTPRequest.h>
#include <Poco/Net/SocketAddress.h>
#include <Poco/SharedPtr.h>
#include <Poco/Timespan.h>

#include "core/DeviceCache.h"
#include "core/PollableDevice.h"
#include "model/DeviceDescription.h"
#include "model/DeviceID.h"
#include "model/GatewayID.h"
#include "model/ModuleID.h"
#include "model/ModuleType.h"
#include "model/RefreshTime.h"
#include "model/SensorData.h"
#include "net/HTTPEntireResponse.h"
#include "util/Loggable.h"

namespace BeeeOn {

class VPTDevice : public PollableDevice, protected Loggable {
public:
        typedef Poco::SharedPtr<VPTDevice> Ptr;

        static const std::vector<std::string> REG_BOILER_OPER_TYPE;
        static const std::vector<std::string> REG_BOILER_OPER_MODE;
        static const std::vector<std::string> REG_MAN_ROOM_TEMP;
        static const std::vector<std::string> REG_MAN_WATER_TEMP;
        static const std::vector<std::string> REG_MAN_TUV_TEMP;
        static const std::vector<std::string> REG_MOD_WATER_TEMP;

        static const std::list<ModuleType> ZONE_MODULE_TYPES;
        static const std::list<ModuleType> BOILER_MODULE_TYPES;

        static const int COUNT_OF_ZONES;

        enum Action {
                PAIR = 0x01,
                READ,
                SET
        };

        VPTDevice(
                const Poco::Net::SocketAddress& address,
                const Poco::Timespan& httpTimeout,
                const Poco::Timespan& pingTimeout,
                const GatewayID& id,
                const RefreshTime& refresh,
                const DeviceCache::Ptr deviceCache);

        DeviceID id() const override;
        RefreshTime refresh() const override;
        DeviceID boilerID() const;
        Poco::Net::SocketAddress address() const;
        void setAddress(const Poco::Net::SocketAddress& address);
        void setPassword(const std::string& pwd);
        Poco::FastMutex& lock();

        void poll(Distributor::Ptr distributor) override;

        std::string generateStamp(const Action action);

        void stampVPT(const Action action);

        void requestModifyState(const DeviceID& id, const ModuleID module,
                const double value);

        std::vector<SensorData> requestValues();

        std::vector<DeviceDescription> descriptions(const RefreshTime& refresh) const;

        bool operator==(const VPTDevice& other) const;

        static DeviceID createSubdeviceID(const int zone, const DeviceID& id);

        static DeviceID omitSubdeviceFromDeviceID(const DeviceID& id);

        static int extractSubdeviceFromDeviceID(const DeviceID& id);

        static std::string extractNonce(const std::string& response);
        static std::string generateHashPassword(const std::string& pwd, const std::string& response);

private:
        void buildDeviceID();

        void requestSetModBoilerOperationType(const int zone, const double value);
        void requestSetModBoilerOperationMode(const int zone, const double value);
        void requestSetManualRoomTemperature(const int zone, const double value);
        void requestSetManualWaterTemperature(const int zone, const double value);
        void requestSetManualTUVTemperature(const int zone, const double value);
        void requestSetModWaterTemperature(const int zone, const double value);

        std::string parseZoneAttrFromJson(const std::string& json, const int zone, const std::string& key);

        HTTPEntireResponse prepareAndSendRequest(const std::string& registr, const std::string& value);

        HTTPEntireResponse sendSetRequest(Poco::Net::HTTPRequest& request);
        HTTPEntireResponse sendRequest(Poco::Net::HTTPRequest& request, const Poco::Timespan& timeout) const;

private:
        DeviceID m_boilerId;
        Poco::Net::SocketAddress m_address;
        std::string m_password;

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

        GatewayID m_gatewayID;
        Poco::FastMutex m_lock;

        DeviceCache::Ptr m_deviceCache;
};

}