#include <UA_AppProbe.hpp>
#include <SIP_MessageContainer.h>
#include <unistd.h>
#include <sys/time.h>
#include <UA_Session.hpp>
#include <iostream>
#include <memory>
#include <stdio.h>
#include "SIP_Probe.h"

extern int             G_reply;
extern int             G_time_wait;
extern int             G_trace;
extern int             G_closeMode;
extern int             G_Buggy_terminated;
extern int             G_destroy_on_unsubscribe;
extern int             G_snn_option;
extern int             G_subscribe;
extern int             G_new_call;
extern int             G_expires;
extern int             G_refer;
extern std::string     G_referTo;
extern int             G_reinvite;
extern int             G_stateless_messages;
extern char          * G_service_username;
extern int             G_nfinishedCalls;
extern int             G_silent;
extern sip_msg_uri_t * G_redir;
extern int             G_server_close;

const char * VP_control_event_to_string(int event)
{
  switch(event) {
  case FF_ID_UPDATE: return "FF_ID_UPDATE";
  case FF_SESS_MUST_BE_DELETED : return "FF_SESS_MUST_BE_DELETED";
  case FF_SESS_MUST_BE_DELETED_ON_ERR : return "FF_SESS_MUST_BE_DELETED_ON_ERR";
  case FF_SESS_WILL_BE_DELETED : return "FF_SESS_WILL_BE_DELETED";
  case FF_SESS_CALL_CREATION_FAIL : return "FF_SESS_CALL_CREATION_FAIL";
  case FF_SESS_LP_SENDING_FAIL : return "FF_SESS_LP_SENDING_FAIL";
  case FF_SESS_INVALID_PROV_CALLID : return "FF_SESS_INVALID_PROV_CALLID";
  case FF_SESS_B2B_PROXY_NO_INCCALL : return "FF_SESS_B2B_PROXY_NO_INCCALL";
  case FF_SESS_B2B_NOT_REQUEST : return "FF_SESS_B2B_NOT_REQUEST";
  case FF_SESS_PROV_CALLID_NOT_SET : return "FF_SESS_PROV_CALLID_NOT_SET";
  case FF_SESS_SAP_NOT_INITIALIZED : return "FF_SESS_SAP_NOT_INITIALIZED";
  case FF_SESS_INVALID_LPID : return "FF_SESS_INVALID_LPID";
  case FF_LP_BADLY_INITIALIZED : return "FF_LP_BADLY_INITIALIZED";
  case FF_LP_INTERNAL_ERR : return "FF_LP_INTERNAL_ERR";
  case FF_LP_DIALOG_RELEASE_ERR : return "FF_LP_DIALOG_RELEASE_ERR";
  case FF_LP_CALL_PROCESSING_ERROR : return "FF_LP_CALL_PROCESSING_ERROR";
  case FF_LP_DIALOG_PROCESSING_ERROR : return "FF_LP_DIALOG_PROCESSING_ERROR";
  case FF_LP_TRANS_PROCESSING_ERROR : return "FF_LP_TRANS_PROCESSING_ERROR";
  case FF_LP_SUBS_PROCESSING_ERROR : return "FF_LP_SUBS_PROCESSING_ERROR";
  case FF_LP_INVALID_PROV_CALLID : return "FF_LP_INVALID_PROV_CALLID";
  case FF_LP_INVALID_PROV_DIALOGID : return "FF_LP_INVALID_PROV_DIALOGID";
  case FF_LP_INVALID_PROV_TRANSID : return "FF_LP_INVALID_PROV_TRANSID";
  case FF_LP_INVALID_PROV_SUBSID : return "FF_LP_INVALID_PROV_SUBSID";
  case FF_LP_CALL_CREATION : return "FF_LP_CALL_CREATION";
  case FF_LP_DIALOG_CREATION : return "FF_LP_DIALOG_CREATION";
  case FF_LP_SUBS_CREATION : return "FF_LP_SUBS_CREATION";
  case FF_LP_MAXCALLS_REACHED : return "FF_LP_MAXCALLS_REACHED";
  case FF_LP_MAXDIALOGS_REACHED : return "FF_LP_MAXDIALOGS_REACHED";
  case FF_LP_MAXTRANS_REACHED : return "FF_LP_MAXTRANS_REACHED";
  case FF_LP_MAXSUBS_REACHED : return "FF_LP_MAXSUBS_REACHED";
  case FF_CALL_LOCAL_SRV_ERROR : return "FF_CALL_LOCAL_SRV_ERROR";
  case FF_CALL_TRANSACTION_DELETED : return "FF_CALL_TRANSACTION_DELETED";
  case FF_CALL_TRANSACTION_DELETED_INTERNAL :
    return "FF_CALL_TRANSACTION_DELETED_INTERNAL";
  case FF_CALL_DIALOG_DELETED : return "FF_CALL_DIALOG_DELETED";
  case FF_CALL_DIALOG_DELETED_INTERNAL :
    return "FF_CALL_DIALOG_DELETED_INTERNAL";
  case FF_CALL_DIALOG_DETAILED_REPORT :
    return "FF_CALL_DIALOG_DETAILED_REPORT";
  case FF_CALL_SUBSCRIPTION_DELETED : return "FF_CALL_SUBSCRIPTION_DELETED";
  case FF_CALL_SUBSCRIPTION_DELETED_INTERNAL :
    return "FF_CALL_SUBSCRIPTION_DELETED_INTERNAL";
  case FF_CALL_SUBSCRIPTION_TIMEOUT : return "FF_CALL_SUBSCRIPTION_TIMEOUT";
  case FF_CALL_REGISTRATION_DELETED : return "FF_CALL_REGISTRATION_DELETED";
  case FF_CALL_REGISTRATION_DELETED_INTERNAL :
    return "FF_CALL_REGISTRATION_DELETED_INTERNAL";
  case FF_UNKNOWN_ERROR : return "FF_UNKNOWN_ERROR";
  default:
    {
      static char value[10];
      sprintf(value, "--%d--", value);
      return value;
    }
  }
}

void print_message_info(sip_msg_message_t * L_Message_recv, 
                        const  char       * send_recv)
{
  if (G_trace >= 1) std::cerr << "== Entering print_message_info" << std::endl;
  if(G_silent) {
    return;
  }

  if (L_Message_recv == 0) {
    printf("Empty Message received\n");
    return;
  }
  
  char uri_string[255];
  
  int VI_index = sip_msg_find_and_parse_header
	(L_Message_recv -> headers,
	 SIP_MSG_HDR_FROM,
	 0, NULL);
  
  if(VI_index >= 0) {
    sip_msg_print_uri(L_Message_recv -> headers -> 
                      vector[VI_index] -> structured_header ->
                      content.from.uri, 
                      uri_string, 255, NULL);
  } else {
    uri_string[0] = 0;
  }

  
  if (L_Message_recv->kind==SIP_MSG_REQUEST) {
    
    if(uri_string[0]) {
      printf("%s %s from '%s'.\n",
             send_recv, 
             sip_msg_method_to_string
             (L_Message_recv->start_line.request.method,
              L_Message_recv->start_line.request.extension_method),
             uri_string);
    } else {
      printf("%s %s.\n",
             send_recv, 
             sip_msg_method_to_string
             (L_Message_recv->start_line.request.method,
              L_Message_recv->start_line.request.extension_method));
    }
  } else {
    printf("%s %d %s.\n",
           send_recv,
           L_Message_recv->start_line.response.status_code,
           L_Message_recv->start_line.response.reason_phrase ? 
           L_Message_recv->start_line.response.reason_phrase : "");
  }
  if (G_trace >= 1) std::cerr << "== EDN of print_message_info" << std::endl;
}

UA_AppProbe::UA_AppProbe
(const char* P_name, 
 const char* P_sipUserInfo, 
 const char* P_hostname, 
 const int P_port, 
 const SIP_TransportType P_trp, 
 const SIP_LogicalEntityType P_LE) 
  : /*probe(0),*/
    copyName("master"),
    SIP_AppProbe(P_name,
                 P_sipUserInfo, 
                 P_hostname, 
                 P_port, 
                 P_trp,
                 P_LE)
{
  if (G_trace >= 1)
    std::cerr <<"== UA_AppProbe:UA_AppProbe  constructor"  
              <<"\n== ---Probe Name         : " << P_name
              <<"\n== ---SIP User Info      : " << P_sipUserInfo
              <<"\n== ---hostname           : " << P_hostname
              <<"\n== ---port               : " << P_port
              <<"\n== ---SIP Logical Entity : " << P_LE
              <<"\n== ---SIP Transport Type : " << P_trp  << std::endl;
}

UA_AppProbe::UA_AppProbe (const char* P_name,const char * P_copyName)
  : /*probe(0),*/copyName(P_copyName),
    SIP_AppProbe(P_name)
{
  if (G_trace >= 1)
    std::cerr <<"== UA_AppProbe:UA_AppProbe  constructor"  
              <<"\n== ---Probe Name         : " << P_name 
              <<"\n== ---Probe copy Name         : " << copyName<< std::endl;
}

UA_AppProbe::~UA_AppProbe()
{
  if (G_trace >= 1)
    std::cerr << "== UASListeningPoint listening Point Name :"
              << getName() << std::endl ;
}


int UA_AppProbe::reportStateChanged (SIP_ProbeState P_newState, 
                                     SIP_Cause P_cause) throw ()
{
  if (G_trace >= 1)
    std::cerr << "==  UA_AppProbe::reportStateChanged new state is [" 
              << P_newState << "], cause [" << P_cause << "]" <<std::endl;
  return 0;
}


int UA_AppProbe::sendSubscriptionMessage(SIP_Service& P_service, 
                                         UA_Session&  P_session, 
                                         SIP_Event&   P_message)
{
  if (G_trace >= 1)
    std::cerr <<"== myAppProbeClient::sendSubscriptionMessage"<<std::endl;
  std::string L_transport;
  
  if (getTransport() == SIP_TRANSPORT_TCP)
    L_transport = "tcp";
  else
    L_transport = "udp";
      
  SIP_MessageContainer* L_event = 0;

  // derivated from vbo sample code
  sip_msg_header_t * L_eventhdr = 0;
  sip_msg_header_t * L_expires  = 0;

  sip_msg_message_t * l_sipRequest = 0;
		
  sip_msg_header_vector_t * L_headerVector = 0;
		
  sip_status_t L_sip_rc;
  sip_msg_error_t error;
  
  L_headerVector = sip_msg_new_header_vector (&error);

  if (!L_headerVector)
    {
      std::cerr <<"== Unable to build the header vector"<<std::endl;
      return -1;
    }
		
  static int L_id = 0;
  char       L_idstr[10];
  L_id++;
 
  sprintf(L_idstr, "%d", L_id);
 
  L_eventhdr = sip_msg_new_event_header((char *)"TESTEVENT",
                                        L_idstr,
                                        NULL,
                                        NULL);    
  if(!L_eventhdr) 
    {
      std::cerr <<"== Unable to build the event: header\n"<<std::endl;
      return -1;
    }

  L_sip_rc = sip_msg_insert_header (L_headerVector,L_eventhdr,-1);
  if (L_sip_rc != SIP_NORMAL)
    {
      std::cerr << "==  Unable to insert header to "
                <<error.unexpected_token<<std::endl;
      return -1;
    }

  L_expires = sip_msg_new_expires_header(G_expires,
                                         NULL,
                                         NULL);
  if(!L_expires) 
    {
      std::cerr <<"== Unable to build the expires: header\n"<<std::endl;
      return -1;
    }

  L_sip_rc = sip_msg_insert_header (L_headerVector,L_expires,-1);
  if (L_sip_rc != SIP_NORMAL)
    {
      std::cerr << "==  Unable to insert header to "
                <<error.unexpected_token<<std::endl;
      return -1;
    }
    
  l_sipRequest = sip_msg_new_request 
    (SIP_MSG_SUBSCRIBE,
     (sip_msg_uri_s *)P_session.getReqUri(),
     NULL,
     L_headerVector,
     0,
     0,
     0,
     &error );
  
  if (!l_sipRequest)
    {
      std::cerr <<"== Unable to build new Request "
                <<error.unexpected_token<<std::endl;
      return -1;
    }

  L_event = new SIP_MessageContainer;
  L_event->setPayload(l_sipRequest);
  L_event->setCallId(FF_Identifier(1,P_session.getProviderCallId()));
  L_event->setDialogId(FF_Identifier(1,P_session.getProviderDialogId()));
  L_event->setTransactionId(FF_Identifier(1,-1));
  L_event->setSubscriptionId(FF_Identifier(1,-1));  

  print_message_info(l_sipRequest, "Sending");

  getProbe().send(P_service,P_session,*L_event);
  return 0;

}


int UA_AppProbe::ProcessSubscriptionMessage(SIP_Service& P_service, 
                                            SIP_Session& P_session, 
                                            SIP_Event&   P_message)
{					    
  int                      VB_message_processed  = -1;
  int                      VI_header_index       = -1;
  int                      VB_unsubscribe        = 0;
  sip_msg_header_t       * VP_event_header       = NULL;
  sip_msg_header_t       * VP_expires_header     = NULL;
  sip_msg_header_t       * VP_contact_header     = NULL;
  sip_msg_message_t      * VP_Message_rsp        = NULL;
  sip_msg_message_t      * VP_Message_recv       = NULL;
  sip_msg_header_t       * VP_subscription_state = NULL;
  SIP_Event              * L_response            = NULL;
  SIP_Status               status;
    if (G_trace >= 1)
    std::cerr <<"== myAppProbeClient::sendSubscriptionMessage"<<std::endl;
	
  FF_SipMessageContainer & VP_RecvEvent = 
    dynamic_cast <FF_SipMessageContainer&>(P_message);
  VP_Message_recv = VP_RecvEvent.getPayload();
  
  try {
    
    if (VP_Message_recv->kind==SIP_MSG_REQUEST) {
      
      VP_event_header = VP_Message_recv -> headers -> vector
        [sip_msg_find_and_parse_header
         (VP_Message_recv -> headers,
          SIP_MSG_HDR_EVENT,
          0, NULL)];
      
      VI_header_index = sip_msg_find_and_parse_header
        (VP_Message_recv -> headers,
         SIP_MSG_HDR_CONTACT,
         0, NULL);
      
      if (VI_header_index != -1)
        {
          VP_contact_header = 
            VP_Message_recv -> headers -> vector[VI_header_index];
        }    
      
      switch(VP_Message_recv->start_line.request.method) {
	
      case SIP_MSG_SUBSCRIBE: {

        char from_string[255];
	  
        VB_message_processed = 1;
	  
        sip_msg_header_t * from_header  = VP_Message_recv -> headers -> 
          vector[sip_msg_find_and_parse_header
                 (VP_Message_recv -> headers,
                  SIP_MSG_HDR_FROM,
                  0, NULL)];
	  
        if(sip_msg_print_header(from_header, 
                                from_string, 255, SIP_FALSE, NULL) > 0) {

          if (G_trace >= 1) {
            fprintf(stderr, 
                    "== SUBSCRIBE for event '%s' received from %s.\n",
                    VP_event_header -> structured_header -> 
                    content.event.event_type,
                    from_string);
          }
        }

        VI_header_index = sip_msg_find_and_parse_header
          (VP_Message_recv -> headers,
           SIP_MSG_HDR_EXPIRES,
           0, NULL);	  
        if(VI_header_index >= 0) {
          VP_expires_header = 
            VP_Message_recv -> headers -> vector[VI_header_index];
          if (G_trace >= 1) {
            fprintf(stderr, "== Expires = %d.\n", 
                    VP_expires_header -> structured_header ->
                    content.expires.delta_seconds);
          }
          if(VP_expires_header -> structured_header ->