/*
 * File:   MessageTransfer.h
 * Author: jgaebler
 *
 * Created on May 4, 2010, 5:18 PM
 */
#pragma once

#ifndef _MESSAGETRANSFER_H
#define	_MESSAGETRANSFER_H

#include "LTNodeQueue.h"
#include "MulticastMessageQueue.h"
#include "common/time/VirtualLogicalTime.h"
#include "timer/MTTimerQueue.h"

#include "common/container/PeerList.h"
#include "common/MoversightService.h"

namespace ubeeme {
    namespace moversight {

        class MulticastMessage;
        class Dispatcher;
        class MessageReference;
        class MembershipService;
        class TimeService;
        class Moversight;
        class MTTimer;
        class Peer;
        class MulticastMessage;
        class LTMessage;
        class GTMessage;

        /**
         * @class MessageTransfer
         * @brief Provides a virtual synchrony send service based on the MOVS.
         * @ingroup Moversight
         * @author Jan Gäbler
         */
        class MessageTransfer : public MoversightService {
            friend class MTTimer;
            friend class LTTimer;
            friend class GTTimer;
            friend class GTAwaitTimer;

            friend class GarbageTimer;

        public:

            MessageTransfer(Dispatcher & d);
            virtual ~MessageTransfer();

            virtual void initialise();
            virtual void finalise();

            void send( MulticastMessage& msg);

            void handleMessage( MulticastMessage* pdu);
            void handleMessage(LTMessage * pdu);
            void handleMessage(GTMessage * pdu);

            void handleGarbageTimer(MTTimer * timer);
            void handleGTTimer(MTTimer * timer);
            void handleLTTimer(MTTimer * timer);
            void handleGTAwaitTimer(MTTimer * timer);

            void localPeerUpdated(Peer & localPeer);
            void handleEvent(const PeerLeftEvent & e);
            MessageTransfer & operator=(const MessageTransfer & other);

            virtual const VirtualLogicalTime & getLastSeenLogicalTime() const;

        private:

            void enqueue( const MulticastMessage& pdu);
            void updateQueue( const MoversightMessage& pdu);

            void sortAndDeliver();
            void cleanMessageQueues();

            MTTimer * setupTimer(MTTimer* timer, MessageReference & mRef, PeerID missedPeer, const VirtualLogicalTime & aLt);
            MTTimer * setupTimer(MTTimer* timer, MessageReference & mRef, PeerIDList & missingPeers, const VirtualLogicalTime & aLt);

            void createAndStartGTAwaitTimer(MessageReference & mRef, const VirtualLogicalTime & alt);
            void createAndStartGTTimer(MessageReference & messageRef, const VirtualLogicalTime & alt);
            void createAndStartGarbageTimer(MessageReference & mRef);

            void stopAllTimers();
            MTTimer * stopLTGTOrGarbageTimer( const MessageReference & mRef);
            void stopAndDeleteTimer(MessageReference & mRef);

            void updateTimer( const MoversightMessage* const pdu);
            void updateTimer( MTTimer* const timer, const MoversightMessage* const pdu);
            void updateMessage( MulticastMessage* msg, VirtualLogicalTime& aLt, MTTimer* timer);
            void updateMissingPeersInLastMessageQueue( const MoversightMessage* const pdu);

            bool resendMessageToPeers( MTTimer* const timer);
            void resendLTMessageToPeer(MessageReference & mRef);
            void resendGTMessageToPeer( const MessageReference& mref, const LTMessage* const pdu);

            void copyMissingPeersAndForeignMissingPeersToMessage(MoversightMessage * pdu, MTTimer * timer);

            bool isLTCollectingCompleted( const MessageReference & mRef);
            bool isPrimaryMaster(PeerID lastHop);

            MembershipService & ms();
            TimeService & ts();

            VirtualLogicalTime lastSeenLt;

            LTNodeQueue queue;
            MTTimerQueue timerQueue;
            MTTimerQueue gtAwaitTimerQueue;
            MulticastMessageQueue lastMessageQueue;

            unsigned int sequ;

        };
    }
}
#endif	/* _MESSAGETRANSFER_H */