#ifdef __cplusplus
extern "C" {
#endif



#ifndef SS_H
#define SS_H

#ifdef __cplusplus
extern "C" {
#endif


#include <rvcommon.h>
#include <psyntree.h>
#include <pvaltree.h>

DECLARE_OPAQUE(HSSAPP);
DECLARE_OPAQUE(HSSAPPAPP);
DECLARE_OPAQUE(HSSSERVICE);
DECLARE_OPAQUE(HSSAPPSERVICE);
DECLARE_OPAQUE(HSSCALL);
DECLARE_OPAQUE(HSSAPPCALL);
DECLARE_OPAQUE(HSSOPER);
DECLARE_OPAQUE(HSSAPPOPER);

typedef enum
{
    csMessageSetup,
    csMessageCallProceeding,
    csMessageAlerting,
    csMessageConnect,
    csMessageReleaseComplete,
    csMessageFacility,
    csMessageProgress,
    csMessageAny

} csStateEnum;

typedef enum
{
    ssDefaultAck,
    ssDefaultNack,
    ssWait
} ssAction;

typedef int (CALLCONV *ssEvServicePrimitiveT)(
                            IN      HSSSERVICE  hSSServ,
							IN      HSSAPPSERVICE  hSSaServ,
							IN	    int			code,
							IN	    BOOL		ack,
							IN	    BOOL		ok,
							IN      char*		role,
                            IN      int         parameters);

typedef int (CALLCONV *ssEvServiceExitedT)(
                            IN      HSSSERVICE  hSSServ,
							IN      HSSAPPSERVICE  hSSaServ);



typedef  struct 
{
    ssEvServicePrimitiveT ssEvServicePrimitive;  
    ssEvServiceExitedT	  ssEvServiceExited;  
} SSSSERVICEEVENT,*SSSERVICEEVENT;


typedef int (CALLCONV *ssEvCallNewMessageT)(
                            IN      HSSCALL     hSSCall,
                            IN      HSSAPPCALL  hSSaCall,
							IN	    csStateEnum	csState,
                            IN      char*       buff,
                            IN      int         size);

typedef int (CALLCONV *ssEvCallReleaseT)(
                            IN      HSSCALL     hSSCall,
                            IN      HSSAPPCALL  hSSaCall,
						    IN      HSSSERVICE  hSSServ,
						    IN      HSSAPPSERVICE  hSSaServ);


typedef int (CALLCONV *ssEvCallNewOperationT)(
						    IN      HSSCALL     hSSCall,
						    IN      HSSAPPCALL  hSSaCall,
							IN      HSSOPER     hSSOper,
							OUT     HSSAPPOPER* hSSaOper);

typedef int (CALLCONV *ssEvCallBeforeEncodingT)(
                            IN      HSSCALL     hSSCall,
                            IN      HSSAPPCALL  hSSaCall,
							IN	    csStateEnum	csState,
							IN		int			message);

typedef  struct 
{
    ssEvCallNewMessageT	    ssEvCallNewMessage;  
    ssEvCallReleaseT	    ssEvCallRelease;  
    ssEvCallNewOperationT   ssEvCallNewOperation;
	ssEvCallBeforeEncodingT	ssEvCallBeforeEncoding;  
} SSSCALLEVENT, *SSCALLEVENT;

typedef int (CALLCONV *ssEvOperationInvokeT)(
                            IN      HSSOPER     hSSOper,
							OUT     BOOL*       origin);

typedef int (CALLCONV *ssEvOperationReturnResultT)(
                            IN      HSSOPER     hSSOper,
							OUT     BOOL*       origin);

typedef int (CALLCONV *ssEvOperationReturnErrorT)(
							IN      HSSOPER     hSSOper,
							OUT     BOOL*       origin);

typedef  struct 
{
  ssEvOperationInvokeT		ssEvOperationInvoke;
  ssEvOperationReturnResultT	ssEvOperationReturnResult;
  ssEvOperationReturnErrorT	ssEvOperationReturnError;
} SSSOPEREVENT, *SSOPEREVENT;

    
/* Initialization/ Shutdown */
 
RVAPI int CALLCONV ssInit(  IN	    char  *	name,
                            OUT     HSSAPP*     hSSApp,
                            IN      HSSAPPAPP   hSSaApp);

RVAPI int CALLCONV ssEnd(   IN      HSSAPP      hSSApp);

RVAPI int CALLCONV ssSetHandle(
                            IN      HSSAPP      hSSApp,
                            IN      HSSAPPAPP   hSSaApp);

RVAPI int CALLCONV ssGetHandle(
                            IN      HSSAPP      hSSApp,
                            IN      HSSAPPAPP*  hSSaApp);

RVAPI int CALLCONV ssSetCallEventHandler(
                            IN      HSSAPP      hSSApp,
                            IN      SSCALLEVENT ssCallEvent,
							IN      int         size);

RVAPI int CALLCONV ssGetCallEventHandler(
                            IN      HSSAPP      hSSApp,
                            IN      SSCALLEVENT ssCallEvent,
							IN      int         size);

RVAPI int CALLCONV ssSetOperEventHandler(
							IN      HSSAPP      hSSApp,
							IN      SSOPEREVENT cmOperEvent,
							IN      int         size);

RVAPI int CALLCONV ssGetOperEventHandler(
                            IN      HSSAPP      hSSApp,
							OUT     SSOPEREVENT ssOperEvent,
							IN      int         size);

RVAPI int CALLCONV ssGetVersion(
                            OUT     char*       buffer,
                            IN      int         size);

RVAPI int CALLCONV ssSetDefaultAddress(
                            IN      HSSAPP      hSSApp,
							IN	    int		addrNodeId);


/*Services*/
/* Creates new instance of service */
RVAPI int CALLCONV ssCreateService(
                            IN      HSSAPP      hSSApp,
                            OUT     HSSSERVICE* hSSServ,
                            IN      HSSAPPSERVICE hSSaServ,
							IN	    char*	serviceName);

RVAPI int CALLCONV ssServiceSetHandle(
                            IN      HSSSERVICE  hSSServ,
                            IN      HSSAPPSERVICE hSSaServ);

RVAPI int CALLCONV ssServiceGetHandle(
                            IN      HSSSERVICE  hSSServ,
                            IN      HSSAPPSERVICE*hSSaServ);

RVAPI int CALLCONV ssSetServiceEventHandler(
                            IN      HSSAPP      hSSApp,
                            IN      SSSERVICEEVENT ssServiceEvent,
							IN      int         size);

RVAPI int CALLCONV ssGetServiceEventHandler(
                            IN      HSSAPP      hSSApp,
                            IN      SSSERVICEEVENT ssServiceEvent,
							IN      int         size);

RVAPI int CALLCONV ssServiceClose(
                            IN      HSSSERVICE  hSSServ);


RVAPI int CALLCONV ssServiceAddCall(
                            IN      HSSSERVICE  hSSServ,
                            IN      HSSCALL     hSSCall,
							IN	    char*	role);

RVAPI int CALLCONV ssServiceGetCall(
                            IN      HSSSERVICE  hSSServ,
							IN	    char*	role,
                            IN      HSSCALL*     hSSCall);

/*Calls*/
RVAPI int CALLCONV ssCreateCall(
							IN      HSSAPP      hSSApp,
                            IN      HSSCALL     *hSSCall,
							IN      HSSAPPCALL  hSSaCall);


RVAPI int CALLCONV ssCallSetHandle(
                            IN      HSSCALL     hSSCall,
                            IN      HSSAPPCALL  hSSaCall);
RVAPI int CALLCONV ssCallGetHandle(
                            IN      HSSCALL     hSSCall,
                            IN      HSSAPPCALL* hSSaCall);

RVAPI int CALLCONV ssCallClose(
                            IN      HSSCALL     hSSCall);

RVAPI int CALLCONV ssCallEncodeMessage(
			    IN	    HSSCALL	hSSCall,
				IN      int		message,
			    IN	    char*	buffer,
			    IN	    int		size);

RVAPI int CALLCONV ssCallDecodeMessage(
							IN	    HSSCALL	hSSCall,
							IN	    csStateEnum	csState,
							IN	    char*	buffer,
							IN	    int		size);

RVAPI int CALLCONV ssCallProcessMessage(
							IN	    HSSCALL	hSSCall,
							IN		int		message);

RVAPI int CALLCONV ssCallDestroyMessage(
							IN	    HSSCALL	hSSCall,
							IN		int		message);


RVAPI int CALLCONV ssCallNewMessage(
							IN	    HSSCALL	hSSCall,
							IN	    csStateEnum	csState,
							IN	    char*	buffer,
							IN	    int		size);

/*Operations*/

RVAPI int CALLCONV ssCallNewOperation(
                            IN      HSSCALL     hSSCall,
							OUT     HSSOPER*    hSSOper,
							IN      HSSAPPOPER  hSSaOper);

RVAPI int CALLCONV ssOperationGetOrigin(
                            IN      HSSOPER     hSSOper);

RVAPI int CALLCONV ssOperationSetHandle(
                            IN      HSSOPER     hSSOper,
							IN      HSSAPPOPER  hSSaOper);

RVAPI int CALLCONV ssOperationInvoke(
                            IN      HSSOPER     hSSOper);

RVAPI int CALLCONV ssOperationReturnResult(
                            IN      HSSOPER     hSSOper);

RVAPI int CALLCONV ssOperationGetPVTHandle(
                            IN      HSSOPER     hSSOper);

RVAPI int CALLCONV ssOperationReturnError(
							IN      HSSOPER     hSSOper);

/*Primitives*/


RVAPI int CALLCONV ssServicePrimitive(
                            IN      HSSSERVICE  hSSServ,
							IN	    int		code,
							IN	    BOOL	ack,
							IN	    BOOL	ok,
							IN      char*	role,
                            IN      int         parameters);


RVAPI HPVT CALLCONV ssGetValTree(
							IN	    HSSAPP	hSSApp);
RVAPI HPST CALLCONV ssGetSynTreeByRootName(
							IN	    HSSAPP	hSSApp,
							IN	    char*       name);



typedef enum
{
    ssCTIdentify	   =  7,
    ssCTAbandon		   =  8,
    ssCTInitiate	   =  9,
    ssCTSetup		   = 10, 
    ssCTActive		   = 11,
    ssCTComplete	   = 12,
    ssCTUpdate             = 13,
    ssCTSubaddressTransfer = 14
} ctPrimitivesEnum;


typedef  enum
{
    ssCDActivateDiversionQ	 = 15,		
    ssCDDeactivateDiversionQ	 = 16,		
    ssCDInterrogateDiversionQ	 = 17,		
    ssCDCheckRestriction	 = 18,		
    ssCDCallRerouting		 = 19,			

    ssCDDivertingLegInformation1 = 20,	
    ssCDDivertingLegInformation2 = 21,	
    ssCDDivertingLegInformation3 = 22,	
    ssCDDivertingLegInformation4 = 100,	
    ssCDDivertedLegFailed	 = 23
} cdPrimitivesEnum;


#ifdef __cplusplus
}
#endif
#endif

#ifdef __cplusplus
}              
#endif