Connection.h

#pragma once

#include "SimHandler.h"
#include "Address.h"
#include "PacketConnectionFeedback.h"
#include "PacketConnectionMessage.h"
#include "PacketConnectionData.h"
#include "Timer.h"
#include "ConnectionTag.h"

class CConnection
{
public:
    enum EConnectionType
    {
        REQUESTER = 0,
        RESPONDER = 1
    };

    enum EState
    {
        CLOSED = 0,
        OPENING = 1,
        OPENED = 2,
        CLOSING = 3,
        CANCELING = 4,
        WAITING = 5
    };

    enum EOpenResult
    {
        OPEN_SUCCESS = 0,
        OPEN_CANCELED = 1,
        OPEN_FAIL_TIMEOUT = 2,
        OPEN_FAIL_REMOTE = 3
    };

    enum ECloseResult
    {
        CLOSE_CONFIRMED = 0,
        CLOSE_TIMEOUT = 1,
        CLOSE_COMPLETE = 2
    };

private:
    static __uint32     idGlobal;
    static __uint32     flowGlobal;

    // Timer timeout values
    static __time       timerOpenTimeout;
    static __time       timerCloseTimeout;
    static __time       timerCancelTimeout;
    static __time       timerRequesterWaitTimeout;
    static __time       timerResponderWaitTimeout;
    static __time       timerDefaultWaitTimeout;

    // Functions
    void                (CConnection::*functionOpen)();
    void                (CConnection::*functionClose)();
    
    void                (CConnection::*functionRecvMessageOpen)(CPacketConnectionMessage*);
    void                (CConnection::*functionRecvMessageOpenAck)(CPacketConnectionMessage*);
    void                (CConnection::*functionRecvMessageClose)(CPacketConnectionMessage*);
    void                (CConnection::*functionRecvMessageCloseAck)(CPacketConnectionMessage*);
    void                (CConnection::*functionRecvMessageCloseAckAck)(CPacketConnectionMessage*);

    // Tag
    CConnectionTag*     tag;

protected:
    // Type
    EConnectionType     type;

    // State
    EState              state;

    // Simulator
    CSimHandler*        sim;

    // Flow
    __uint32            flow;

    // Local connection
    __uint32            id;
    __uint32            idEntry;
    __uint16            port;

    // Remote connection
    CAddress            remoteAddress;
    __uint32            remoteId;
    __uint32            remoteIdEntry;
    __uint16            remotePort;

    // Timers
    CTimer<CConnection>*
                        timerControl;

    // Delegates
    IDelegate5<void, __uint16, __uint16, CAddress, __byte, CPacket*>*
                        delegateSend;

    // Events
    Event2<void, CConnection*, EOpenResult>*
                        eventOpen;
    Event2<void, CConnection*, ECloseResult>*
                        eventClose;

    // Calls
    Call1<CConnection*>*
                        callDispose;

    // String
    static char*        strConnectionType[];
    static char*        strState[];
    char                str[256];

public:
    CConnection(
        EConnectionType                                                     type,
        __uint32                                                            idEntry,
        __uint16                                                            port,
        CSimHandler*                                                        sim,
        IDelegate5<void, __uint16, __uint16, CAddress, __byte, CPacket*>*   delegateSend,
        IDelegate1<void, CConnection*>*                                     delegateDispose,
        CAddress                                                            remoteAddress,
        __uint16                                                            remotePort
        );
    virtual ~CConnection();

    inline EConnectionType  Type() { return this->type; }
    inline EState           State() { return this->state; }

    inline __uint32         Id() { return this->id; }
    inline __uint32         IdEntry() { return this->idEntry; }
    inline __uint16         Port() { return this->port; }

    inline __uint32         RemoteId() { return this->remoteId; }
    inline __uint32         RemoteIdEntry() { return this->remoteIdEntry; }
    inline CAddress         RemoteAddress() { return this->remoteAddress; }
    inline __uint16         RemotePort() { return this->remotePort; }

    // Events
    inline Event2<void, CConnection*, EOpenResult>*
                            EventOpen() { return this->eventOpen; }
    inline Event2<void, CConnection*, ECloseResult>*
                            EventClose() { return this->eventClose; }

    // Calls
    inline Call1<CConnection*>*
                            CallDispose() { return this->callDispose; }     // Call when the object can be disposed

    // Functions
    void                    Open();
    void                    Close();

    // Receive
    void                    Recv(CAddress src, CPacketConnection* packet);

    // Tag
    inline CConnectionTag*
                            Tag() { return this->tag; }
    inline void             Tag(CConnectionTag* tag) { this->tag = tag; }

    char*                   ToString() const;

protected:
    // Send
    bool                    SendData(CPacketConnectionData* packet);

    // Receive
    virtual void            Recv(CPacketConnection* packet) = 0;
    virtual void            RecvData(CPacketConnectionData* packet) = 0;
    virtual void            RecvFeedback(CPacketConnectionFeedback* packet) = 0;
    void                    RecvMessage(CPacketConnectionMessage* packet);

    void                    RecvMessageOpenRequester(CPacketConnectionMessage* packet);
    void                    RecvMessageOpenAckRequester(CPacketConnectionMessage* packet);
    void                    RecvMessageCloseRequester(CPacketConnectionMessage* packet);
    void                    RecvMessageCloseAckRequester(CPacketConnectionMessage* packet);
    void                    RecvMessageCloseAckAckRequester(CPacketConnectionMessage* packet);

    void                    RecvMessageOpenResponder(CPacketConnectionMessage* packet);
    void                    RecvMessageOpenAckResponder(CPacketConnectionMessage* packet);
    void                    RecvMessageCloseResponder(CPacketConnectionMessage* packet);
    void                    RecvMessageCloseAckResponder(CPacketConnectionMessage* packet);
    void                    RecvMessageCloseAckAckResponder(CPacketConnectionMessage* packet);

    // Functions
    void                    OpenRequester();
    void                    OpenResponder();

    void                    CloseRequester();
    void                    CloseResponder();

    // Timers
    void                    TimerOpen(CTimerInfo* info);    
    void                    TimerClose(CTimerInfo* info);   
    void                    TimerCancel(CTimerInfo* info);
    void                    TimerWait(CTimerInfo* info);
};