messageManager.h

#pragma once

#include <iostream>
#include <stdio.h>
#include <queue>
#include <list>
#include <boost/thread.hpp>
#include <boost/any.hpp>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/enable_shared_from_this.hpp>
#include <boost/chrono.hpp>
#include <boost/asio/waitable_timer_service.hpp>

#ifdef TESTING
#include "gtest/gtest.h"
#endif

typedef boost::asio::basic_waitable_timer<boost::chrono::steady_clock> steady_timer; 

class Message
{
public:
    std::string content; 
    int timeout; 
    int retries; 
    std::string expectedInitResponse; 
    std::string expectedEndResponse; 
    std::string receivedResponse=""; 
    Message(std::string content="", int timeout = 100, int retries = 3, std::string expectedInitResponse = "", std::string expectedEndResponse="");
};

class Transaction
{
public:
    std::string id; 
    std::list<Message> messages; 
    int intervalMessage=0; 

    Transaction(){}
    explicit Transaction(std::list<Message> list):messages(list) {}
    explicit Transaction(std::initializer_list<Message> list): messages(list){}
};

enum Status
{
    IDLE, 
    SENDING 
};

class MessageManagerObserver
{
public:
    virtual std::list<std::string> getUnsolicitedInfoCodes(){
        std::list<std::string> list;
        return list;
    }

    virtual void transactionProcessed(boost::system::error_code error_code, Transaction transaction) = 0;

    virtual void unsolicitedInfo(const std::string& message) = 0;

    virtual ~MessageManagerObserver()
    {
    }
};

class MessageManager: public boost::enable_shared_from_this<MessageManager>
{
public:
    explicit MessageManager();
    virtual ~MessageManager();
    static std::string stringToHex(const std::string& input, bool printAsciiChar);

    boost::system::error_code subscribe(MessageManagerObserver* observer);
    boost::system::error_code unsubscribe(MessageManagerObserver* observer);
    boost::system::error_code sendAsync(const Transaction& transaction);
    
    virtual bool rebootCommunications() = 0;
#ifdef TESTING
    virtual boost::system::error_code sendSync(Transaction& transaction);
#else
    boost::system::error_code sendSync(Transaction& transaction);

#endif

protected:
    boost::asio::io_service mIo; 
    
    virtual boost::system::error_code send(std::string message) = 0;
    
    void receivedMessage(const char* data, size_t size);
    virtual boost::system::error_code receiveUntil(int timeout, std::string& receivedResponse);

private:
    boost::thread bt;
    std::vector<boost::shared_ptr<boost::thread>> mTransactionThreads;
    steady_timer m_processQueueTimer;
    std::list<Transaction> mQueue; 
    Status mStatus;
    std::vector<MessageManagerObserver*> m_observersList;
    int mCounter = 0;
    std::string mDataReceived;
    std::string mResponse;
    int mConsecutiveErrors = 0;
    bool mWaiting;
    bool mWorking;
    Message mLastMessageSent;
    std::mutex mMuxCV, mMuxStatus, mMuxQueue; 
    std::condition_variable mConditionVar; 
    Status getStatus();
    void setStatus(Status status);
    void processQueue(const boost::system::error_code& ec);
    void processTransactions(std::list<Transaction>& queue);
    void processMessages(boost::system::error_code& ec, std::list<Message>& messages, int interval=0);
    void processSingleTransaction(boost::system::error_code& ec, Transaction transaction);
    boost::system::error_code sendAndReceive(Message& message);

#ifdef TESTING
public:
    FRIEND_TEST(MessageManager_test, Send_ASyncNoRetries);
    FRIEND_TEST(MessageManager_test, Send_ASyncRetries);
    FRIEND_TEST(MessageManager_test, Send_ReceiveOK);
    FRIEND_TEST(MessageManager_test, Send_ReceiveKO);
    FRIEND_TEST(MessageManager_test, UnsolicitedInfoIdle);
    FRIEND_TEST(MessageManager_test, UnsolicitedInfoBusy);
    FRIEND_TEST(MessageManager_test, receiveUntilTimeoutExpired);
    FRIEND_TEST(MessageManager_test, ReceiveMessageNoInitNoEnd);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitNoEnd);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitNoEndError);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitNoEndDoubleMessage);
    FRIEND_TEST(MessageManager_test, ReceiveMessageNoInitEndCorrectly);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitEndCorrectly);
    FRIEND_TEST(MessageManager_test, ReceiveMessageInitEndDoubleMsg);
    FRIEND_TEST(MessageManager_test, BrokenUnsolicitedInfoMsg);
    FRIEND_TEST(MessageManager_test, BrokenRequestMsg);
    FRIEND_TEST(MessageManager_test, CoupledMsg_RequestUnsolicited);
    FRIEND_TEST(MessageManager_test, CoupledMsg_UnsolicitedRequest);
    FRIEND_TEST(MessageManager_test, CoupledMsg_RequestRequest);
    FRIEND_TEST(MessageManager_test, IncompleteUnsolicitedMsg);
    FRIEND_TEST(MessageManager_test, IncompleteRequestMsg);
    FRIEND_TEST(MessageManager_test, UnsolicitedMsgWhile_RequestInitAndEndMsg);
    FRIEND_TEST(MessageManager_test, UnsolicitedMsgWhile_RequestInit);
    FRIEND_TEST(MessageManager_test, UnsolicitedMsgWhile_RequestEnd);
    FRIEND_TEST(MessageManager_test, UnsolicitedMsgWhile_RequestNoInitNoEnd);
#endif
};