//--------------------------------------  
// USSD EAE write for ussd test
// Author: lw 2006/7/10
//--------------------------------------

#include "./include/smpp.h"

#define ISDN_LEN 8

typedef struct GameSession
{
        BYTE   LinkNo;
        BYTE   flag;
        BYTE   ussd_ref;
        BYTE   seed[4];
        BYTE   ssm_state;
        BYTE   shmsg[256];
        BYTE   us_prm;
        BYTE   input[4];
        BYTE   history[512];
        BYTE   count;
        char   msisdn[(ISDN_LEN+1)*2+2];
}
GameSession;



typedef enum _USSD_OP
{
	PSSDR = 0 ,  // MAP_Process_USS_Data request operation
	PSSRR = 1 ,  // MAP_Process_USS_Request request operation
	USSRR = 2 ,  // MAP_USS_Request Request operation
	USSNR = 3 ,  // MAP_USS_Notify Request operation
	OPENR = 4 ,  // open request operation
	RELR  = 5 ,  // Release request operation
  
	PSSDA = 6 ,  // MAP_Process_USS_Data Answer   operation
	PSSDE = 7 ,  // MAP_Process_USS_Data error   operation
	
	PSSRA = 8 ,  // MAP_Process_USS_Request Answer   operation
	PSSRE = 9 ,  // MAP_Process_USS_Request error   operation
	
	USSRA = 10 ,  // MAP_USS_Request Answer  operation
	USSRE = 11,  // MAP_USS_Request Error   operation
	
	USSNA = 12,  // MAP_USS_Notify Answer   operation
	USSNE = 13,  // MAP_USS_Notify  Error operation
	
	OPENE = 14,  // open error   operation
	RELE  = 15,  // Release error   operation
	
	PSSDS = 16,  // MAP_Process_USS_Data confirm operation
	PSSRS = 17,  // MAP_Process_USS_Request confirm operation
	USSRC = 18,  // MAP_USS_Request Confirm operation
	USSNC = 19,  // MAP_USS_Notify Confirm operation
	
	USSRS = 20,  // MAP_USS_Request response operation
	USSNS = 21,  // MAP_USS_Notify response operation
	PSSRC = 22,  // MAP_Process_USS_Request confirm operation
	OPENC = 23,  // open confirm operation
	RELC  = 24,  // Release confirm operation
} 
USSD_OP;

struct ussd_op
{
        char      *s;
        USSD_OP    v;
};

#define USSD_OP_NUM 25
#define USSD_OP_LEN 5

static const struct ussd_op op_map_name[25] = {
	{ "PSSDR" , PSSDR },  // 0  MAP_Process_USS_Data request operation 
	{ "PSSRR" , PSSRR },  // 1  MAP_Process_USS_Request request operation 
	{ "USSRR" , USSRR },  // 2  MAP_USS_Request Request operation
	{ "USSNR" , USSNR },  // 3  MAP_USS_Notify Request operation
  { "OPENR" , OPENR },  // 4  open request operation
  { "RELR " , RELR  },  // 5  Release request operation
  
  { "PSSAE" , PSSDA },  // 6  MAP_Process_USS_Data Answer    operation
  { "PSSDE" , PSSDE },  // 7  MAP_Process_USS_Data error   operation
  
  { "PSSRE" , PSSRA },  // 8  MAP_Process_USS_Request Answer   operation
  { "PSSRE" , PSSRE },  // 9  MAP_Process_USS_Request error   operation
  
  { "USSRA" , USSRA },  // 10  MAP_USS_Request Answer  operation
  { "USSRE" , USSRE },  // 11 MAP_USS_Request Error   operation
  
  { "USSNA" , USSNA },  // 12 MAP_USS_Notify Answer  operation
	{ "USSNE" , USSNE },  // 13 MAP_USS_Notify Error   operation
	
	{ "OPENE" , OPENE },  // 14 open error   operation
	{ "RELE " , RELE  },  // 15 Release error   operation
  
  { "PSSDS" , PSSDS },  // 16 MAP_Process_USS_Data confirm operation
  { "PSSRS" , PSSRS },  // 17 MAP_Process_USS_Request confirm operation
  { "USSRC" , USSRC },  // 18 MAP_USS_Request Confirm operation
  { "USSNC" , USSNC },  // 19 MAP_USS_Notify Confirm operation
  
  { "USSRS" , USSRS },  // 20 MAP_USS_Request response operation
  { "USSNS" , USSNS },  // 21 MAP_USS_Notify response operation
  { "PSSRC" , PSSRC },  // 22 MAP_Process_USS_Request confirm operation
	{ "OPENC" , OPENC },  // 23 open confirm operation
	{ "RELC " , RELC  },  // 24 Release confirm operation	
};

typedef enum US_STATE
{
	 US_IDLE=0,
	 US_OPENR,
	 US_OPENC,
	 US_OPENE,
	 US_PSSRR,
	 US_PSSRA,
	 US_PSSRE,
	 US_PSSRC,
	 US_PSSRS,
	 US_USSRR,
	 US_USSRC,
	 US_USSRS,
	 US_USSNR,
	 US_USSNC,
	 US_USSNS,
	 US_RELER,
	 US_RELEC,
	 US_RELES,
	 US_RELEE,
}
US_STATE;

#define MAX_GAME_SESSION 255

typedef struct GuessGame
{
	     BYTE   wxc2_hlr_number[8];
	     char   service_number[8];
	     BYTE   link_enable;
       BYTE   link;	     
}GuessGame;

GuessGame gg;


struct GameSession ssm_data[MAX_GAME_SESSION];

#define SD_PKT_NUM	10
#define STORE_MSG_ITEM	60

typedef struct	SMPP_MSG_STORE_STRUCT
{
	BYTE	short_message[SMPP_MSG_LEN];
	BYTE	message_id[65];
} SMPP_MSG_STORE_STRUCT;


#define MAX_GAME_LINK 1

static struct itimerval itimer,old_itimer;
static int		timer_counter[MAX_GAME_LINK];
static int		stateFlag[MAX_GAME_LINK];
static int		msg_count[MAX_GAME_LINK];
static int		msg_pointer[MAX_GAME_LINK];
static SMPP_MSG_STORE_STRUCT	store_msg_buf[MAX_GAME_LINK][STORE_MSG_ITEM];

static void On_Timer();
static void SetTimer();
static void smpp_test_init();
static int  smpp_onDataRecv(BYTE linkNo, SMPP_MSG *pData, WORD dataLen);
static int  smpp_onLinkStateChange(BYTE linkNo, BYTE linkstate);

BYTE hae_isdn_ston(BYTE *normal_isdn,BYTE *str_isdn)
{
	BYTE		ii;
	BYTE		len;

	len = strlen(str_isdn);
	if (len > ISDN_LEN*2-2)
		return 0;
	if ((len % 2) == 1)		// odd number
	{
		AsciiToBcd(normal_isdn+1,str_isdn,len-1);
		ii = len/2 + 1;
		normal_isdn[ii] = (str_isdn[len-1] - '0') << 4;
		normal_isdn[ii] |= 0x0E;
	}
	else
	{
		AsciiToBcd(normal_isdn+1,str_isdn,len);
		ii = len/2;
	}
	memset(normal_isdn+ii+1,0xEE,ISDN_LEN-ii-1);
	normal_isdn[0] = 0x91;	// default value
	return 1;
}


void hae_isdn_ntos(BYTE *str_isdn,BYTE *normal_isdn)
{
	BYTE		len = 0;
	BYTE		ii,jj;

	for (ii = 1;ii < ISDN_LEN;ii ++)
	{
		jj = (normal_isdn[ii] >> 4) & 0x0f;
		if (jj > 0x0c)
			break;
		str_isdn[len++] = jj + '0';
		jj = normal_isdn[ii] & 0x0f;
		if (jj > 0x0c)
			break;
		str_isdn[len++] = jj + '0';
	}
	str_isdn[len] = '\0';
}

int register_link()
{
	BYTE	        ret;
	
	strcpy( gg.service_number , "86755001");
	
	if( gg.link == MAX_SMPP_LINK+1 )
	{
		ret = smpp_registerLink(SMPP_CLIENT, BIND_TRX, gg.service_number, TRANSACTION);
		if ((ret&0x80) == 0x80) 
		{
			 gg.link = ret&0x7f;
			 printf("Get link for GuessGame EAE .link:%d",  gg.link);
			 smpp_attach_link(gg.link, smpp_onDataRecv, smpp_onLinkStateChange);
			 return 1;
		}
  }
  else
  {
  	  smpp_attach_link(gg.link, smpp_onDataRecv, smpp_onLinkStateChange);
	    return 1;
  }
	return 0;
}

void smpp_test_init(int flag)
{
	int  i;
	
	FILE *fp;
	char line[32];
	char test_file[] = "./conf/guess_number_test.conf";
	
  gg.link_enable = 0;
  gg.link = MAX_SMPP_LINK+1;
	for (i=0; i<MAX_GAME_LINK; i++)
	{
		memset(store_msg_buf[i], 0, sizeof(SMPP_MSG_STORE_STRUCT)*STORE_MSG_ITEM);
		msg_pointer[i]	= 0;
	}
	strcpy(gg.wxc2_hlr_number, "86755001");
	register_link();
	
	if( flag )
	{
			fp = fopen( test_file , "r");
			if( fp == NULL )
			{
				  printf("Open %s file fail!\n", test_file );
			}
			
			
			 while ( !feof ( fp ) )
		   {
		        if( fgets ( line, 256, fp ) == NULL )
		        {
		            break;
		        }
		        
		        for( i = 16 ; i > 6 ; i -- )
		        {
		        	 if( line[i] == ' ' || line[i] == '\t' || line[i] == '\r' || line[i] == '\n')
		        	 {
		        	 	  continue;
		        	 }
		        	 else if( isdigit( line[i] ) )
		        	 {
		        	 	  break;
		        	 }
		        }
		        if( i < 16 && i > 6 )
		        {
		        	 line[i+1] = '\0';
		        } 
		        line[16] = '\0';
		        for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
		    	  {
		
		    	  	 	 if( !ssm_data[i].flag )
		    	  	 	 {
		    	  	 	    ssm_data[i].flag = 1;
		    	  	 	    ssm_data[i].ssm_state =6;
		    	  	 	    printf("read msisdn :%s\n",line);
		    	  	 	    strcpy ( ssm_data[i].msisdn, line );
		                //hae_isdn_ston ( temp_isdn, temp_msisdn ); 
		                //memcpy( ssm_data[i].msisdn ,  temp_isdn , ISDN_LEN);   
		                break;
		             }
		    	 }
		   }
	}
}

extern int iptrMainInit();


int main(int argc,char *argv[])
{
	int i;
	char ret;

	heartbeat_init(0xFFFF);
	debug_init();
	iptrMainInit();
	snmp_init(SMPP_PORT);
	mtp_shm_init();
	sccp_init();

	smpp_init_new();
	while ((ret = getopt(argc,argv,"n")) != -1)
	{
		switch (ret)
		{
			case 'n':
				printf("\n\n\nNetwork initial ussd to ms\n\n\n");
				smpp_test_init(1);
				break;
			default:
				smpp_test_init(0);
				break;
		}
	}
	
  
	for (i=0; i<MAX_GAME_LINK; i++)
	{
		stateFlag[i]	= FALSE;
		timer_counter[i]= 0;
		msg_count[i]	= 0;
	}

	opterr = 0;
	


	SetTimer();
	while(1)
	{
		usleep(50);
	}
	return 1;
}

void GameFsm();

static int call_flag = 0;

void On_Timer()
{
	int i;
	

	for (i=0; i<MAX_GAME_LINK; i++)
	{	// 2 msgs per second
		if (timer_counter[i]==25)
			timer_counter[i]=0;
		if ((timer_counter[i]%25)==0)
		{
			if( (call_flag++)%2 == 0 )
			{ 
			   GameFsm();
			}
		}
		timer_counter[i]++;

		if (msg_count[i] == SD_PKT_NUM)
		{
			smpp_close(i);
		}
	}

	iptrans_timer();
	debug_rt();
	snmp_timer();
	mtp3_proc();
	heartbeat_timer();
	sccp_timer();
	smpp_fsm_new();
}

void SetTimer()
{
	struct sigaction	act;
	act.sa_handler=On_Timer;
	sigemptyset(&act.sa_mask);
	act.sa_flags=0;
	if(sigaction(SIGALRM,&act,NULL)<0)
	{
		perror("Produce Sigaction");
		exit(1);
	}
	
	itimer.it_interval.tv_sec=0;
	itimer.it_interval.tv_usec=20*1000;
	itimer.it_value.tv_sec=0;
	itimer.it_value.tv_usec=20*1000;

	if (setitimer(ITIMER_REAL,&itimer,&old_itimer) !=0 )
	{
		printf("Setting Timer  error! \n");
		exit(1);
	}
}

void SendMsgToSMPP(int sid , BYTE* msg , BYTE ussd_op);


int smpp_onDataRecv(BYTE linkNo, SMPP_MSG *pMsg, WORD dataLen)
{
	int sequence_number=100;
	SMPP_MSG	smpp_msg;
	int i;
	//BYTE  temp_isdn[ISDN_LEN+1];
	//BYTE  temp_msisdn[65];
	struct GameSession *ssm_ptr;
	char  temp_str[256];

	switch (pMsg->message_type)
	{

	case 0x0C:	/* SUBMIT SM RESP */
		printf("[TEST PROGRAM]Link %d received SUBMIT SM RESP.\n", linkNo);
		break;
	case 0x0F:	/* DELIVER SM */
		printf("[TEST PROGRAM]Link %d received DELIVER SM. op:%d \n", linkNo , pMsg->pdu.deliver_sm.ussd_service_op);
    switch( pMsg->pdu.deliver_sm.ussd_service_op )
    {
    	 case PSSRR:
    	 	    smpp_send_ascout("\33[32mGuess Game Recv PSSRR\33[0m\n");
    	 	    if( pMsg->pdu.deliver_sm.user_message_reference >=  MAX_GAME_SESSION )
    	      {
    	      	   smpp_send_ascout("\33[32mThe session id is too large!\33[0m\n");
    	      	   return -1;
    	      }
    	 	    for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
    	      {
    	  	     if( pMsg->pdu.deliver_sm.user_message_reference == ssm_data[i].ussd_ref )
    	  	     {
    	  	 	       if( ssm_data[i].flag == 1)
    	  	 	       {
	                    smpp_send_ascout("\33[32mThe session id is in used!\33[0m\n");
    	  	 	   	      return -1;
    	  	 	       }
    	  	 	   }
    	  	 	}    
    	  	 	for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
    	      {
    	  	 	       if( ssm_data[i].flag == 0)
    	  	 	       {
	                    break;
    	  	 	       }
    	  	 	}  
    	  	  ssm_data[i].flag = 1;
    	  	 	ssm_data[i].ssm_state =1;
    	  	 	ssm_data[i].ussd_ref = pMsg->pdu.deliver_sm.user_message_reference;
    	  	 	strcpy ( ssm_data[i].msisdn, pMsg->pdu.deliver_sm.source_addr );
    	 	    break;
    	 case USSRC:
    	 	    for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
    	      {
    	  	     if( strcmp( pMsg->pdu.deliver_sm.source_addr ,ssm_data[i].msisdn ) == 0 )
    	  	     {
    	  	 	       break;
    	  	 	   }
    	  	 	}
    	  	 	if( i == MAX_GAME_SESSION )
    	  	 	{
    	  	 		 printf( "unkown USSRC msisdn :%s \n",pMsg->pdu.deliver_sm.source_addr );
    	  	 		 SendMsgToSMPP(  pMsg->pdu.deliver_sm.user_message_reference ,ssm_ptr->shmsg , RELR );
    	  	 		 ssm_ptr->us_prm = US_RELER;
    	  	 		 return -1;
    	  	 	}
    	 	    ssm_ptr = &ssm_data[i];
    	 	    ssm_ptr->us_prm = US_USSRC;
    	 	    smpp_send_ascout("\33[32mGuess Game Recv USSRC\33[0m\n");
    	 	    sprintf(temp_str, "\33[32mGame Fsm state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , pMsg->pdu.deliver_sm.user_message_reference);
			      smpp_send_ascout(temp_str); 
    	 	    if( pMsg->pdu.deliver_sm.sm_length == 4 )
    	 	    {
    	 	        memcpy( &ssm_ptr->input , &pMsg->pdu.deliver_sm.short_message  ,4);
    	 	        ssm_ptr->input[0] -= '0'; 
    	 	        ssm_ptr->input[1] -= '0';
    	 	        ssm_ptr->input[2] -= '0';
    	 	        ssm_ptr->input[3] -= '0';
    	 	    }
    	 	    strcpy( ssm_ptr->shmsg , pMsg->pdu.deliver_sm.short_message  );
    	 	    ssm_ptr->shmsg[pMsg->pdu.deliver_sm.sm_length]  = '\0';
    	 	    break;
    	 case USSNC:
    	 	    for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
    	      {
    	  	     if( strcmp( pMsg->pdu.deliver_sm.source_addr ,ssm_data[i].msisdn ) == 0 )
    	  	     {
    	  	 	       break;
    	  	 	   }
    	  	 	}
    	  	 	if( i == MAX_GAME_SESSION )
    	  	 	{
    	  	 		 printf( "unkown USSRC msisdn :%s \n",pMsg->pdu.deliver_sm.source_addr );
    	  	 		 if( pMsg->pdu.deliver_sm.user_message_reference < MAX_GAME_SESSION )
    	  	 		 {
    	  	 		     ssm_ptr = &ssm_data[i];
    	  	 		     strcpy(  ssm_ptr->shmsg , " incorrect user msg reference " );
    	  	 		     SendMsgToSMPP(  pMsg->pdu.deliver_sm.user_message_reference ,ssm_ptr->shmsg , RELR );
    	  	 		 }
    	  	 		 return -1;
    	  	 	}
    	 	    ssm_ptr = &ssm_data[i];
    	 	    ssm_ptr->us_prm = US_USSNC;
    	 	    smpp_send_ascout("\33[32mGuess Game Recv USSNC\33[0m\n");
    	 	    break;
    	 case RELR:
    	 	     for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
    	      {
    	  	     if( strcmp( pMsg->pdu.deliver_sm.source_addr ,ssm_data[i].msisdn ) == 0 )
    	  	     {
    	  	 	       break;
    	  	 	   }
    	  	 	}
    	  	 	if( i == MAX_GAME_SESSION )
    	  	 	{
    	  	 		 
    	  	 		 //sprintf( ssm_ptr->shmsg ,"unkown RELR msisdn :%s \n",pMsg->pdu.deliver_sm.source_addr );
    	  	 		 //SendMsgToSMPP(  pMsg->pdu.deliver_sm.user_message_reference ,ssm_ptr->shmsg , RELR );
    	  	 		 return -1;
    	  	 	}
    	 	    ssm_ptr = &ssm_data[i];
    	 	    ssm_ptr->us_prm = US_RELEC;
    	 	    smpp_send_ascout("\33[32mGuess Game Recv RELR\33[0m\n");
    	 	    break;
    	 case RELC:
    	 	    for( i = 0 ; i <  MAX_GAME_SESSION ; i ++ )
    	      {
    	  	     if( strcmp( pMsg->pdu.deliver_sm.source_addr ,ssm_data[i].msisdn ) == 0 )
    	  	     {
    	  	 	       break;
    	  	 	   }
    	  	 	}
    	  	 	if( i == MAX_GAME_SESSION )
    	  	 	{
    	  	 		 printf( "unkown RELC msisdn :%s \n",pMsg->pdu.deliver_sm.source_addr );
    	  	 		 SendMsgToSMPP(  pMsg->pdu.deliver_sm.user_message_reference ,ssm_ptr->shmsg , RELR );
    	  	 		 return -1;
    	  	 	}
    	 	    ssm_ptr = &ssm_data[i];
    	 	    ssm_ptr->us_prm = US_RELES;
    	 	    smpp_send_ascout("\33[32mGuess Game Recv RELR\33[0m\n");
    	 	    break;
    	 default:
    	 	    break;
    }
		
		/* fill with DELIVER SM RESP structure. */
		smpp_msg.message_type	= 0x10;
		smpp_msg.pdu.deliver_sm_resp.head.command_status	= htonl(ESME_ROK);
		smpp_msg.pdu.deliver_sm_resp.head.sequence_number	= pMsg->pdu.deliver_sm.head.sequence_number;
		smpp_msg.pdu.deliver_sm_resp.message_id				    = 0x0;
		smpp_send(linkNo, &smpp_msg, dataLen);
		smpp_send_ascout("Send deliver_sm_resp\n");
		call_flag = 0;
		break;
  }
	return sequence_number;
}

int smpp_onLinkStateChange(BYTE linkNo, BYTE linkstate)
{
	printf("[TEST PROGRAM]link %d state change to %d\n",linkNo, linkstate);
	if (linkstate == 1)
		gg.link_enable	= 1;
	else
		gg.link_enable	= 0;

	return linkNo;
}

int RandomNum(BYTE *seed)
{
	  int count , i , j;
	  i = j = count = 0 ;
    while( count < 4 )
    {
    	  j = 1 +(int)(10.0*rand()/(RAND_MAX+1.0));
    	  if( j >= 10 )
    	  {
    	  	continue;
    	  }
    	  for( i = count ; i > 0 ; i-- )
    	  {
    	  	 if( j == seed[i] )
    	  	 {
    	  	 	  break;
    	  	 }
    	  }
    	  if( !count || j !=  seed[i])
    	  {
    	  	 seed[count] = j;
    	  	 count++;
    	  }
    }
    return (count == 4 ? 1 : 0);
}


int CheckInput(BYTE *input)
{
    int input_index ,index;
    
    for( input_index = 0 ; input_index < 4 ; input_index++ )
    {
        for( index = 0 ; index < 4 ; index++ )
        {
            if( index != input_index && input[input_index] == input[index] )
            {
                return 0;
            }
        }
    } 
    return 1;
}

int GuessNumber(BYTE* input,BYTE* seed)
{
    BYTE seed_index , input_index ;
    BYTE rt_a       , rt_b        ;
    
    rt_a = rt_b = 0;
    for( input_index = 0 ; input_index < 4 ; input_index++ )
    {
        for( seed_index = 0 ; seed_index < 4 ; seed_index++ )
        {
            if( input[(int)input_index] == seed[(int)seed_index] )
            {
                if( input_index == seed_index )
                {
                    rt_a++;
                }
                else 
                {
                    rt_b++;
                }
            }
        }
    } 
    return (rt_a << 4) + rt_b;
}

void SendMsgToSMPP(int sid , BYTE* msg , BYTE ussd_op)
{
	   SMPP_MSG         pMsg;
	   int              data_len;
	   PDU_SUBMIT_SM   *submit_sm;
	   struct GameSession *ssm_ptr;
	   char             temp_str[256];
	   
	   if( sid >= MAX_GAME_SESSION )
	   {
	      ssm_ptr = &ssm_data[sid - MAX_GAME_SESSION]; 
	   }
	   else
	   {
	   	  ssm_ptr = &ssm_data[sid]; 
	   } 
	   memset( &pMsg , 0 , sizeof(SMPP_MSG));
	   
	   submit_sm = &pMsg.pdu.submit_sm; 
	   pMsg.message_type	= 0x0B;
	   pMsg.optional_param_flag1 =  0x08000001;
	   if( sid < MAX_GAME_SESSION )
	     submit_sm->user_message_reference = ssm_ptr->ussd_ref;
	   else
	   	 submit_sm->user_message_reference = 0xFFFF;
	   submit_sm->ussd_service_op        = ussd_op;
	   strcpy( submit_sm->service_type , "USSD" );
	   strcpy( submit_sm->destination_addr , ssm_ptr->msisdn   );
	   strcpy( submit_sm->source_addr      , gg.service_number );
	   //hae_isdn_ntos( submit_sm->destination_addr , ssm_ptr->msisdn ); 
	   sprintf(temp_str, "\33[32mGuessGame send smpp msg: ussd_op :%s  ssm_ptr->msisdn :%s user_refer : %d\33[0m\n" 
	           , op_map_name[submit_sm->ussd_service_op].s ,ssm_ptr->msisdn , submit_sm->user_message_reference);
		 smpp_send_ascout(temp_str);   
     submit_sm->sm_length =  strlen( msg );
     strcpy( submit_sm->short_message , msg );
     smpp_send( gg.link , &pMsg , data_len );
}


void GameFsm()
{
     int rt;
     int i;
     char temp_str[1024];
     struct GameSession *ssm_ptr;
     
     if( !gg.link_enable && !register_link() )
     {
     	    smpp_send_ascout("Try to connect to WXC2 HLR fail\n");
     	    printf("Try to connect to WXC2 HLR fail\n");
  	      return;
     }
     //sprintf(debugBuf,);
	   //smpp_send_ascout("The session id is in used!\n");
     
     for( i = 0 ;i < MAX_GAME_SESSION ; i++)
     {
     	   ssm_ptr = &ssm_data[i];
     	   if( ssm_ptr->flag == 0 )
     	   {
     	   	 continue;
     	   }
     	   if( ssm_ptr->us_prm == US_RELES )
     	   {
     	   	   ssm_ptr->ssm_state = 7;
     	   }
     	   else if( ssm_ptr->us_prm == US_RELEC )
     	   {
     	   	  strcpy( ssm_ptr->shmsg , "Release ack!\n");
     	   	  SendMsgToSMPP( i ,ssm_ptr->shmsg , RELC );
     	   	  ssm_ptr->ssm_state = 7;
     	   }
		     switch( ssm_ptr->ssm_state )
		     {
		     	    case 0:
		     	    	   continue;
		          case 1:		  
		          	   sprintf(temp_str, "\33[32mGame Fsm state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , i);
		          	   smpp_send_ascout(temp_str);        	   
		               if( !RandomNum( ssm_ptr->seed ) )
		               {
		                   //"Create random number fail"
		                   return;
		               }     
		               //sid = pMsg->pdu.deliver_sm.user_message_reference ;
		               //if( sid > MAX_GAME_SESSION )
		               //{
		               //    //"Game EAE do no support so much session .sid :%d",sid
		               //    return;
		               //} 
		               sprintf( ssm_ptr->shmsg ," WellCome to WXC2 Online Guess Number Game System!\n Please input you guess nubmer:\n");
		               SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
		               sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		               smpp_send_ascout(temp_str);
		               ssm_ptr->ssm_state = 2;
		               break;
		          case 2:
		               switch( ssm_ptr->us_prm )
		               {
		               	   case US_IDLE:
		               	        break;
		                   case US_RELER:
		                        break;
		                   case US_USSRC:
		                   	    sprintf(temp_str, "\33[32mGame Fsm state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , i);
		          	            smpp_send_ascout(temp_str);     
		                   	    if( strlen(ssm_ptr->shmsg) != 4 )
							          	   {
							          	   	   sprintf(temp_str, "\33[32mThe input string length is not 4. input again.\33[0m\n");
		          	                 smpp_send_ascout(temp_str);
		          	                 strcpy ( ssm_ptr->shmsg   , "The input string length is not 4. input again."); 
		                             SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
		                             sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                             smpp_send_ascout(temp_str);
		                             ssm_ptr->shmsg[0] = '\0';
		                             ssm_ptr->us_prm  = US_IDLE;
							                   return;
							          	   }  
		                        if( !CheckInput( ssm_ptr->input ) )
		                        {
		                           sprintf( ssm_ptr->shmsg ,"Input is Error! Please input four difference numbers.\n");
		                           SendMsgToSMPP(  i ,ssm_ptr->shmsg , USSRR );
		                        }
		                        rt = GuessNumber( ssm_ptr->input , ssm_ptr->seed ) & 0xFF ;
		                        ssm_ptr->count ++;
		                        if( ssm_ptr->count >= 8 )
		                        {
		                            sprintf ( ssm_ptr->shmsg ,"Game Over!\n");
		                            sprintf ( temp_str , "NO%d:%d%d%d%d ",ssm_ptr->count , ssm_ptr->input[0],ssm_ptr->input[1],ssm_ptr->input[2],ssm_ptr->input[3]);
		                            strcat ( ssm_ptr->history , temp_str );
		                            sprintf ( temp_str         , "->%dA%dB\n" , rt>>4 , rt&0x0F);
		                            strcat  ( ssm_ptr->history , temp_str );
		                            //strcat  ( ssm_ptr->shmsg , ssm_ptr->history );
		                            SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
		                            sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                            smpp_send_ascout(temp_str);
		                            ssm_ptr->ssm_state = 3;
		                            ssm_ptr->us_prm  = US_IDLE;
		                            return ;
		                        }
		                        sprintf( temp_str , "NO%d:%d%d%d%d ",ssm_ptr->count , ssm_ptr->input[0],ssm_ptr->input[1],ssm_ptr->input[2],ssm_ptr->input[3]);
		                        if( rt != 0x40 )
		                        {
		                            strcat ( ssm_ptr->history , temp_str );
		                            sprintf( temp_str         , "->%dA%dB\n" , rt>>4 , rt&0x0F);
		                            strcat ( ssm_ptr->history , temp_str );
		                            strcpy ( ssm_ptr->shmsg   , ssm_ptr->history ); 
		                            SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
		                            sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                            smpp_send_ascout(temp_str);
		                            ssm_ptr->us_prm  = US_IDLE;
		                        }
		                        else
		                        {
		                            strcat ( ssm_ptr->history , temp_str );
		                            sprintf( temp_str         , "->%dA%dB\n" , rt>>4 , rt&0x0F);
		                            strcat ( ssm_ptr->history , temp_str );
		                            strcpy ( ssm_ptr->shmsg   , ssm_ptr->history ); 
		                            SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
		                            sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                            smpp_send_ascout(temp_str);
		                            ssm_ptr->ssm_state = 3;
		                            ssm_ptr->us_prm  = US_IDLE;
		                        }
		                        break;     
		               }
		               break;
              case 3:
              	   if( ssm_ptr->us_prm == US_USSNC )
              	   {
              	       switch( ssm_ptr->count )
		                   {
		                     case 1:
		                        sprintf ( ssm_ptr->shmsg ," So Luck!\n");
		                        break;
		                     case 2:
		                        sprintf ( ssm_ptr->shmsg ," Luck\n");
		                        break;
		                     case 3:
		                        sprintf ( ssm_ptr->shmsg ," Perfect\n");
		                        break;
		                     case 4:
		                        sprintf ( ssm_ptr->shmsg ," Very Good\n");
		                        break;
		                     case 5:
		                        sprintf ( ssm_ptr->shmsg ," Good\n");
		                        break;
		                     case 6:
		                     case 7:
		                     case 8:
		                        sprintf ( ssm_ptr->shmsg ," Correct\n");
		                        break;
		                     default:
		                     	  strcpy ( ssm_ptr->shmsg   , ssm_ptr->history ); 
		                     	  SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
		                        sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                        smpp_send_ascout(temp_str);
		                        ssm_ptr->ssm_state = 4;
		                     	  return;
		                     	  break;
		                  }
		                  SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
		                  sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
		                  smpp_send_ascout(temp_str);
		                  ssm_ptr->ssm_state = 4;
		               }
		          case 4:
		          	   if( ssm_ptr->us_prm == US_USSNC )
              	   {
			          	   sprintf(temp_str, "\33[32mGame Fsm state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , i);
			          	   smpp_send_ascout(temp_str); 
			               sprintf( ssm_ptr->shmsg ," Guess Number\n1 . Restart game \n 2 . exit\n");
			               SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
			               ssm_ptr->ssm_state = 5;  
			               ssm_ptr->count =0;
			               sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
			               smpp_send_ascout(temp_str);
			             }
		               break;
		          case 5:
		          	   if( ssm_ptr->us_prm == US_USSRC )
              	   {
			                if( ssm_ptr->shmsg[0] == '1' )
			                {
			                	 if( !RandomNum( ssm_ptr->seed ) )
		                     {
		                          //"Create random number fail"
		                          return;
		                     }   
		                     sprintf( ssm_ptr->shmsg ," Game Restart.input four difference numbers: \n");
			                   SendMsgToSMPP( i ,ssm_ptr->shmsg , USSRR );
			                   ssm_ptr->history[0]= '\0';
			                   ssm_ptr->ssm_state = 2;
			                }  
			                else if( ssm_ptr->shmsg[0] == '2' )
			                {
			                	 sprintf( ssm_ptr->shmsg ," Game Exit.GoodBye! Wellcome to use WXC2 system!\n");
			                   SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
			                   memset( ssm_ptr , 0 , sizeof(GameSession ));
			                   
			                } 
			                else
			                {
			                	 sprintf( ssm_ptr->shmsg ," Unexpeced menu selection!\n");
			                   SendMsgToSMPP( i ,ssm_ptr->shmsg , USSNR );
			                   ssm_ptr->ssm_state = 7;
			                }
			                sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
			                smpp_send_ascout(temp_str);
			             }
		          	   break;
		         case 6:
		         	     if( gg.link_enable )
		         	     {
			         	     sprintf(temp_str, "\33[32mGame Fsm state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , i);
			          	   smpp_send_ascout(temp_str);        	   
			               if( !RandomNum( ssm_ptr->seed ) )
			               {
			                   //"Create random number fail"
			                   return;
			               }     
			               sprintf( ssm_ptr->shmsg ," WellCome to WXC2 Online Guess Number Game System!\n Please input you guess nubmer:\n");
			               SendMsgToSMPP( i+MAX_GAME_SESSION ,ssm_ptr->shmsg , USSRR );
			               sprintf(temp_str , "\n\n\33[32mSend Game Info :\n%s\33[0m\n\n" , ssm_ptr->shmsg );
			               smpp_send_ascout(temp_str);
		                 ssm_ptr->ssm_state = 2;
		                 sprintf(temp_str, "\33[32mGame Fsm change to state :% d sid : %d\33[0m\n" , ssm_ptr->ssm_state , i);
			          	   smpp_send_ascout(temp_str); 
		         	     }
		         	     break;
		          case 7:  //release
		          	   if( ssm_ptr->us_prm == US_USSNC )
              	   {
              	   	   strcpy( ssm_ptr->shmsg , "session is closed");
              	   	   SendMsgToSMPP( i ,ssm_ptr->shmsg , RELR );
              	   }
		               sprintf(temp_str, "\33[32mRecv Release command ! sid: %d ussd_ref: %d\33[0m\n" , i ,ssm_ptr->ussd_ref);
			          	 smpp_send_ascout(temp_str); 
		          	   memset( ssm_ptr , 0 , sizeof(GameSession ));         	   
		          	   break;
		     }
     }
}