DeviceStatusFetcher.h

#pragma once

#include <map>
#include <set>

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

#include "core/CommandSender.h"
#include "core/DeviceStatusHandler.h"
#include "loop/StoppableRunnable.h"
#include "loop/StopControl.h"
#include "util/Loggable.h"

namespace BeeeOn {

class DeviceStatusFetcher :
        public CommandSender,
        public StoppableRunnable,
        Loggable {
public:
        typedef Poco::SharedPtr<DeviceStatusFetcher> Ptr;

        DeviceStatusFetcher();

        void setIdleDuration(const Poco::Timespan &duration);

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

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

        void registerHandler(DeviceStatusHandler::Ptr handler);

        void clearHandlers();

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

protected:
        class PrefixAnswer : public Answer {
        public:
                typedef Poco::AutoPtr<PrefixAnswer> Ptr;

                PrefixAnswer(
                        AnswerQueue &queue,
                        const DevicePrefix &prefix);

                DevicePrefix prefix() const;

        private:
                const DevicePrefix m_prefix;
        };

        class PrefixStatus {
        public:
                PrefixStatus();

                void startRequest();

                void deliverResponse(bool successful);

                bool needsRequest() const;

                bool shouldRepeat(const Poco::Timespan &repeatTimeout) const;

        private:
                Poco::Clock m_lastRequested;
                bool m_started;
                bool m_successful;
        };

        enum FetchStatus {
                NOTHING,
                WOULD_REPEAT,
                ACTIVE
        };

protected:
        FetchStatus fetchUndone();

        PrefixAnswer::Ptr handleDirtyAnswer(Answer::Ptr answer);

        std::set<DeviceStatusHandler::Ptr> matchHandlers(
                        const PrefixAnswer::Ptr answer) const;

        void processAnswer(
                PrefixAnswer::Ptr answer,
                std::set<DeviceStatusHandler::Ptr> handler);

        void collectPaired(
                std::set<DeviceID> &paired,
                const std::vector<DeviceID> &received,
                const DevicePrefix &prefix) const;

private:
        StopControl m_stopControl;
        Poco::Timespan m_idleDuration;
        Poco::Timespan m_waitTimeout;
        Poco::Timespan m_repeatTimeout;
        std::map<DevicePrefix, std::set<DeviceStatusHandler::Ptr>> m_handlers;
        std::map<DevicePrefix, PrefixStatus> m_status;
};

}