//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project / SIG
//
//File: sigprotocol.h
//
//Version: $Revision: 1.4 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/11/12 08:23:01 $
//
//Organisation:
//      Helsinki University of Technology
//      Laboratory of Telecommunications Software and Multimedia
//
//Author:
//      Sami Raatikainen
//
//Description:
//      Sig protocol conduit implementation. This conduit is connection-
//      oriented so instances are created dynamically above a mux. It
//      implements the main functionality of the signaling protocol.
//
//Copyright:
//
//
//Licence:
//
//
//History: 

#ifndef __SIG_SIGPROTOCOL_H__
#define __SIG_SIGPROTOCOL_H__

class sigPrimitive;
class sigSETUPreq;
class sigSETUPresp;
class sigPROCEEDINGreq;
class sigALERTINGreq;
class sigRELEASEreq;
class sigRELEASEresp;
class sigRESETreq;
class sigRESETresp;
class sigRESET_ERRORresp;
class sigSETUPind;
class sigSETUPconf;
class sigSETUP_COMPLETEind;
class sigPROCEEDINGind;
class sigALERTINGind;
class sigRELEASEind;
class sigRELEASEconf;
class sigRESETind;
class sigRESETconf;
class sigRESET_ERRORind;

#include "pf/protocol.h"
#include "pf/messenge.h"
#include "pf/bytes.h"
#include "sigmode.h"

class sigProtocol : public pfProtocol
{
    public:
        sigProtocol(const sigProtocol &other_);
        virtual ~sigProtocol(void);
        
        // Enabling point-to-point or point-to-multipoint capabilities.
        virtual void createConduits(sigSETUPind *primitive_);
        virtual pfConduit createPointToPointConduits(void);
        virtual pfConduit createMultipointConduits(void);
        
        virtual void setMode(sigMode *mode_);
        virtual void setUserMode(void) = 0;
        virtual void setNetworkMode(void) = 0;

        // To CC, new methods
        virtual void sendSETUPindToCC(sigSETUPind *primitive_);
        virtual void sendSETUPconfToCC(sigSETUPconf *primitive_);
        virtual void sendSETUP_COMPLETEindToCC(sigSETUP_COMPLETEind *primitive_);
        virtual void sendPROCEEDINGindToCC(sigPROCEEDINGind *primitive_);
        virtual void sendALERTINGindToCC(sigALERTINGind *primitive_);
        
        virtual void sendRELEASEconfToCC(pfUlong cause_);
        virtual void sendRELEASEconfToCC(sigRELEASEconf *primitive_);
        virtual void sendRELEASEconfToCC(sigRELEASEind *primitive_);
        
        virtual void sendRELEASEindToCC(sigRELEASEind *primitive_);
        virtual void sendRELEASEindToCC(pfUlong cause_);
        
        virtual void sendRESET_ERRORindToCC(sigRESET_ERRORind *primitive_);
        virtual void sendRESETconfToCC(sigRESETconf *primitive_);
        virtual void sendRESETindToCC(sigRESETind *primitive_);
        

        // To CoOrd
        virtual void sendRESETreqToDown(sigRESETreq *primitive_);
        virtual void sendRESETrespToDown(sigRESETresp *primitive_);
        virtual void sendRESET_ERRORrespToDown(sigRESET_ERRORresp *primitive_);
        
        virtual void sendSETUPreqToDown(sigSETUPreq *primitive_);
        virtual void sendSETUPrespToDown(sigSETUPresp *primitive_);
        virtual void sendSETUP_COMPLETEreqToDown(void);
        virtual void sendPROCEEDINGreqToDown(sigPROCEEDINGreq *primitive_);
        virtual void sendALERTINGreqToDown(sigALERTINGreq *primitive_);
        virtual void sendRELEASEreqToDown(sigRELEASEreq *primitive_);
        virtual void sendRELEASErespToDown(sigRELEASEresp *primitive_);
        

        // State changes
        virtual void changeToNullState(void);
        virtual void changeToCallInitiatedState(void);
        virtual void changeToOutgoingCallProceedingState(void);
        virtual void changeToCallDeliveredState(void);
        virtual void changeToCallPresentState(void);
        virtual void changeToCallReceivedState(void);
        virtual void changeToConnectRequestState(void);
        virtual void changeToIncomingCallProceedingState(void);
        virtual void changeToActiveState(void);
        virtual void changeToReleaseRequestState(void);
        virtual void changeToReleaseIndicationState(void);
        virtual void changeToReleaseCollisionState(void);

        // hook-methods
        virtual void startAwaitCONNECTtimer(void) = 0;
        virtual void releaseCollisionAct(sigRELEASEind *primitive_) = 0;
        virtual void sigAwaitRLCtimeoutAct(void) = 0;
        

        // Call clearing, miscellaneous
        virtual void clearCall(void);
        virtual void clearCall(pfUlong cause_);
        virtual void startReleaseProcess(pfUlong cause_);
        virtual void finalClearing(void);

        virtual void stopAllTimers(void) = 0;

        virtual void reportIncompatibleMessage(pfMessenger *message_) = 0;

        virtual void setCallReference(pfMessenger *message_) = 0;
        

        // Multipoint features
        virtual void setOSideEndpointReference(pfMessenger *message_);
        virtual void setTSideEndpointReference(pfMessenger *message_);
        
        virtual void setMultipointConnection(void);
        virtual bool isMultipointConnection(void);

    protected:
        sigProtocol(void);
        sigMode *_mode;

        enum sigLocation
        {
            sigLocation_User                       = B0000_0000,
            sigLocation_PrivateNWServingLocalUser  = B0000_0001,
            sigLocation_PublicNWServingLocalUser   = B0000_0010,
            sigLocation_TransitNW                  = B0000_0011,
            sigLocation_PublicNWServingRemoteUser  = B0000_0100,
            sigLocation_PrivateNWServingRemoteUser = B0000_0101,
            sigLocation_InternationalNW            = B0000_0111,
            sigLocation_NWBeyondIWPoint            = B0000_1010
        };
        void setLocation(sigLocation location_);
        sigLocation getLocation(void);
        
        virtual void saveMessage(pfMessenger *msg_);
        virtual pfMessenger *getSavedMessage(void);
        
        virtual void toCC(pfMessenger *primitive_);
        
    private:
        bool _multipoint;
        sigLocation _location;
        pfMessenger *_savedMsg;
        //savedType _savedMsgType;
};

#endif // __SIG_SIGPROTOCOL_H__