//Editor-Info: -*- C++ -*-
//
//Subject: TOVE project/CC
//
//File: ccdpstate.h
//
//Version: $Revision: 1.34 $
//
//State: $State: Exp $
//
//Date: $Date: 1998/11/16 15:47:45 $
//
//Organisation:
//      University of Technology
// 
//Author:
//      Pasi Nummisalo
//
//Description:
//      This class is used to handle default actions for
//      INAP and signalling messages for SSF waiting
//      for instruction state and to define an algorithm
//      for hadling different types of Detection Points.      
//
//Copyright:
//      Copyright 1999 Helsinki University of Technology
//      ALL RIGHTS RESERVED BETWEEN JANUARY 1996 AND JUNE 1999.
//      
//Licence:
//     
//
//History:
//

#ifndef __CC_DP_STATE_H__
#define __CC_DP_STATE_H__

#if CC_DEBUG
#include "protocol/cc/ccdebug.h"
#endif

#include "dp.h"
#include "pf/state.h"
#include "iface/sigif/sigupprimitives.h"
#include "iface/binapif/binappdus.h"
#include "ccindications.h"

class pfState; 
class ccState;
class ccDpState;
class ccProtocol;

class ccDpState : public ccInputs,
                  public sigUpInputs,
                  public binapInputs,
                  public pfState

{
    public:
        virtual void proceed(ccProtocol *protocol_) = 0;
        virtual void exitAction(ccProtocol *protocol_, ccState *state_);
        virtual void exitAction(ccProtocol *protocol_, ccDpState *state_);

        virtual toveinap_EventTypeBCSMType getInapType(void) const = 0;
        virtual string getType(void) const;
        virtual ccIf_TriggersType allowedTriggers(void) const;
        
        // Message functions related to specific DP must
        // be implemented in that DP.
        
        // From SCP
     
        // Common

        void binapREQUEST_REPORT_BCSM_EVENTpduAct(
            binapREQUEST_REPORT_BCSM_EVENTpdu *messenger_,
            ccProtocol *protocol_);

        virtual void binapCONTINUEpduAct(
            binapCONTINUEpdu *messenger_,
            ccProtocol *protocol_);

        virtual void binapRELEASE_CALLpduAct(
            binapRELEASE_CALLpdu *messenger_,
            ccProtocol *protocol_);

        virtual void ccTimerSSFtimeoutAct(pfProtocol *protocol_);

        // O-side
        
         virtual void binapAUTHORIZE_ORIGINATIONpduAct(
            binapAUTHORIZE_ORIGINATIONpdu *messenger_,
            ccProtocol *protocol_);

        virtual void binapCOLLECT_INFORMATIONpduAct(
            binapCOLLECT_INFORMATIONpdu *messenger_,
            ccProtocol *protocol_);

        virtual void binapANALYSE_INFORMATIONpduAct(
            binapANALYSE_INFORMATIONpdu *messenger_,
            ccProtocol *protocol_);

        virtual void binapSELECT_ROUTEpduAct(
            binapSELECT_ROUTEpdu *messenger_,
            ccProtocol *protocol_);

        // T-side

        virtual void binapAUTHORIZE_TERMINATIONpduAct(
            binapAUTHORIZE_TERMINATIONpdu *messenger_,
            ccProtocol *protocol_);

        virtual void binapSELECT_FACILITYpduAct(
            binapSELECT_FACILITYpdu *messenger_,
            ccProtocol *protocol_);

        virtual void binapPRESENT_CALLpduAct(
            binapPRESENT_CALLpdu *messenger_,
            ccProtocol *protocol_);

        virtual void unexpectedINAPmessage(ccProtocol *);
        
        //  From lower layer (signalling)
     
        virtual void sigSETUPindAct(sigSETUPind *messenger_,
                                    pfProtocol *protocol_);
               
        virtual void sigPROCEEDINGindAct(sigPROCEEDINGind *messenger_,
                                         pfProtocol *protocol_);
  
        virtual void sigSETUPconfAct(sigSETUPconf *messenger_,
                                     pfProtocol *protocol_);
        
        virtual void sigSETUP_COMPLETEindAct(sigSETUP_COMPLETEind *messenger_,
                                       pfProtocol *protocol_);
        
        virtual void sigRELEASEindAct(sigRELEASEind *messenger_,
                                      pfProtocol *protocol_);
         
        virtual void sigRELEASEconfAct(sigRELEASEconf *messenger_,
                                       pfProtocol *protocol_);
                
        virtual void sigRESETindAct(sigRESETind *messenger_,
                                    pfProtocol *protocol_);

        virtual void sigRESETconfAct(sigRESETconf *messenger_,
                                     pfProtocol *protocol_);

        virtual void sigRESET_ERRORindAct(sigRESET_ERRORind *messenger_,
                                          pfProtocol *protocol_);


        /*
        // Additional
        
        virtual void sigMORE_INFOindAct(sigMORE_INFOind *messenger_,
                                        pfProtocol *protocol_);
        
        virtual void sigINFOindAct(sigINFOind *messenger_,
                                   pfProtocol *protocol_);
        
        virtual void sigPROGRESSindAct(sigPROGRESSind *messenger_,
                                       pfProtocol *protocol_);
        virtual void sigALERTINGindAct(sigALERTINGind *messenger_,
                                       pfProtocol *protocol_);
        virtual void sigNOTIFYindAct(sigNOTIFYind *messenger_,
                                     pfProtocol *protocol_);
        */

        virtual void unexpectedSignallingMessage(pfProtocol *protocol_);

        
        // From other side
        virtual void ccRELEASEpduAct(ccRELEASEpdu *messenger_,
                                     ccProtocol *protocol_);

        virtual void ccRELEASE_ACTIVEpduAct(ccRELEASE_ACTIVEpdu *messenger_,
                                            ccProtocol *protocol_);

        virtual void ccSETUPpduAct(ccSETUPpdu *messenger_,
                                   ccProtocol *protocol_);

        virtual void ccALERTINGpduAct(ccALERTINGpdu *messenger_,
                                      ccProtocol *protocol_);
        
    protected:
        ccDpState(void);
        virtual ~ccDpState(void);
 
        virtual void toNextState(ccDp &dp_, ccProtocol *protocol_) = 0;
        void process(ccDp &dp_, ccProtocol *protocol_);
           
        void processEDP_N(ccDp &dp_, ccProtocol *protocol_);
        void processTDP_N(ccDp &dp_, ccProtocol *protocol_);
        void processEDP_R(ccDp &dp_, ccProtocol *protocol_);
        void processTDP_R(ccDp &dp_, ccProtocol *protocol_);
  
}; 

#endif // __CC_DP_STATE_H__