return iPt;// in queue
				}
			iPt=(++iPt)%MAX_SIZE_QUEUE;
		
		}
	
	return -1;//not in queue

}


/////////////
//packet queue function

int Pkt_InitQueue(gpr_pkt_queue * lpQ)
{
	int i;
	sPkBuff pk_node;
	pk_node.pkt=NULL;
	pk_node.pkt_id=-1;
	

	if (lpQ==NULL)
		return -1;		
	
	for (i=0;i<MAX_SIZE_QUEUE;i++)
		lpQ->queue[i]=pk_node;
	
	lpQ->iHead=0;
	lpQ->iTail=0;
	
	return 0;
	
}

int Pkt_AddItemToQ(sPkBuff iItem,gpr_pkt_queue * lpQ )
{

int iPos;

	iPos=-1;

	if ( ( (lpQ->iTail+1)%MAX_SIZE_QUEUE ) ==lpQ->iHead )
	{//full,overwrite from the head one

	
		iPos=lpQ->iTail;
		lpQ->queue[iPos]=iItem;// add to tail
		lpQ->iTail=(lpQ->iTail+1)%MAX_SIZE_QUEUE;
		lpQ->iHead=(lpQ->iHead+1)%MAX_SIZE_QUEUE;
	
	
	
	}
	else
	{
						

						
		iPos=lpQ->iTail;
		lpQ->queue[iPos]=iItem;// add to tail
	
		lpQ->iTail=(lpQ->iTail +1 )%MAX_SIZE_QUEUE;	
	
	
	}
	
	return iPos;


}

int pkt_GetHeadIndex(gpr_pkt_queue * lpQ)
{
	if (lpQ!=NULL)
		return (lpQ->iHead);
	else 
		return -1;
}

int GetNum_pkt_q(gpr_pkt_queue * lpQ)
{
	if (lpQ==NULL)
		return (-2);

	if (lpQ->iHead==lpQ->iTail)
		return (1);

	
	if (lpQ->iHead<lpQ->iTail)
		return lpQ->iTail-lpQ->iHead;
	
	if (lpQ->iHead>lpQ->iTail)
		return MAX_SIZE_QUEUE+lpQ->iTail-lpQ->iHead;	
	
	
	return -1;//abnormal, i cant wonder


}

int Is_pkt_q_empty(gpr_pkt_queue * lpQ)
{
	if (lpQ==NULL)
		return (-2);

	if (lpQ->iHead==lpQ->iTail)
		return (1);
	else
		return (0);
	


}

sPkBuff  gpr_access_pkt_q(gpr_pkt_queue * lpQ)
{
Packet * pkt;
sPkBuff iItem_ret;
pkt=NULL;
iItem_ret.pkt_id=-1;
iItem_ret.pkt=NULL;
	if (lpQ==NULL)
		return (iItem_ret);

	if (lpQ->iHead!=lpQ->iTail)
		{

			iItem_ret=lpQ->queue[lpQ->iHead];

			return iItem_ret;
			
		}

	return iItem_ret;

}

sPkBuff gpr_remove_pkt_q(gpr_pkt_queue * lpQ)
{
sPkBuff iItem_ret;
Packet * pkt;
pkt=NULL;
iItem_ret.pkt_id=-1;
iItem_ret.pkt=NULL;
	if (lpQ==NULL)
		return (iItem_ret);

	if (lpQ->iHead!=lpQ->iTail)
		{

			iItem_ret=lpQ->queue[lpQ->iHead];
			lpQ->iHead=(lpQ->iHead +1)%MAX_SIZE_QUEUE;
			return iItem_ret;
			
		}

	return iItem_ret;

}

int Pkt_GetQItemAt(int iPos,sPkBuff * lpVal, gpr_pkt_queue * lpQ)
{
		
	int iNext;
	
	iNext=-1;
	
	if (iPos!=lpQ->iTail)
	{
		*lpVal=lpQ->queue[iPos];
		
		iNext=(++iPos)%MAX_SIZE_QUEUE;
		
		if (iNext==lpQ->iTail)
			iNext=-1;
	}
	
	return iNext;


}


int Pkt_SetQItemAt(int iPos,sPkBuff Val, gpr_pkt_queue * lpQ)
{
		
	int iNext;
	
	iNext=-1;
	
	if (iPos!=lpQ->iTail)
	{
	    lpQ->queue[iPos]=Val;
		iNext=iPos;
	}
	
	return iNext;


}


int Pkt_Fulsh_Depul_Queue_by_dest(sPkBuff iItem, int iDest ,gpr_pkt_queue * lpQ)
{

	int iPt;
	int iEnd;
	int iDest_pkt;
	
	iPt=lpQ->iHead;
	iEnd=lpQ->iTail;

	while (iPt!=iEnd)
		{
		

						
			op_pk_nfd_get (lpQ->queue[iPt].pkt,"DEST",&iDest_pkt);	
			if (iDest_pkt==iDest)
				{
													
					return iPt;// in queue
				}
			iPt=(iPt+1)%MAX_SIZE_QUEUE;
		
		}
	
	return -1;//not in queue

}

int Pkt_IsInQueue(sPkBuff iItem,gpr_pkt_queue * lpQ )
{

	int iPt;
	int iEnd;
	
	iPt=lpQ->iHead;
	iEnd=lpQ->iTail;

	while (iPt!=iEnd)
		{
		

	
			if (iItem.pkt_id==lpQ->queue[iPt].pkt_id)
				{
				
					
					return iPt;// in queue
				}
			iPt=(iPt+1)%MAX_SIZE_QUEUE;
		
		}
	
	return -1;//not in queue

}
/////////////




void GPR_static_Preset(int dest_addr)
{
int i;

for(i=0;i<5;i++)
	{
	GP_route_cache[dest_addr].Gp_route[i]=i;
	}
GP_route_cache[dest_addr].size_route=5;

	//temp set the group as the node addr
	//my_group_id=my_gpr_address;
}


void gpr_send_to_mac(Packet * pk_ptr, int gpr_addr)
{
int iType;
Ici* iciptr;
	//ARP


	op_pk_nfd_get (pk_ptr,"Type",&iType);	

	iciptr = op_ici_create("GPR_MAC_Dest_ICI");
	op_ici_attr_set(iciptr,"MAC_Destination",gpr_addr);//ztl temp
	op_ici_install(iciptr);
	
	op_pk_send( pk_ptr,TO_MAC_LAYER_STRM);

if (iType==DATA_PACKET_TYPE)
	{
	sprintf(msg,"send data to mac: %d",gpr_addr);
	GPR_message(msg,5);
	}


}


//when rcv na, select best next hop to fwd the queue items 
//returnval is the index of the neighbor
int Select_Next_hop(int iDest,int iCode,int pkt_id)
{
int iRet,iWaitValue;
int i;

int iNext_hop;

int size_route;
int iBestOne,iBig;


iRet=-3;
iWaitValue=-1;


size_route=	GP_route_cache[iDest].size_route;
switch (iCode)
	{
	case ND_REQEST:
	if (size_route!=0)
		return -2;//should dump the request list
	//no route
	iBig=iBestOne=-1;
	for (i=0;i<MAX_SIZE_NODES;i++)
		{
	
		if ( (list_neighbor[i].iINTflag == 1 ) && 
			(list_neighbor[i].dest_addr==iDest) &&
			(list_neighbor[i].iCode==iCode))//the neighbor echo ns
			{
		
			iWaitValue = list_neighbor[i].iWaitValue;
			
			//iWaitValue=iWaitValue+list_neighbor[i].iWaitValue;//component metrics
			
			if (iWaitValue>-1 )
				{
							//can be valued in term of distance to the dest


						if (iBig<iWaitValue)
						{
								iBestOne=i;
								iBig=iWaitValue;
							
						}
							
				
				}

		
			}
		
	}//end of for
		if (iBestOne!=-1)
		{
			iNext_hop=list_neighbor[iBestOne].szNeighborID;
			return iBestOne;
			}
	
	
	break;
	
	case ND_REPLY:

	
	case ND_DATA:
	

	if (size_route==0&&iCode==ND_DATA&&!EPIDEMIC&&!FULL_CONNECT)
		return -2;
	

	iBig=iBestOne=-1;
	for (i=0;i<MAX_SIZE_NODES;i++)
		{
	
		if ( (list_neighbor[i].iINTflag == 1 ) && 
			(list_neighbor[i].dest_addr==iDest) &&
			(list_neighbor[i].iCode==iCode))//the neighbor echo ns
			{
		
			iRet=-1;
			iWaitValue = IsIn_Right_Direction_NA(iDest,list_neighbor[i].szNeighborGroupID,iCode) ;   //*10

			
			if (iWaitValue>-1 )
				{
							//can be valued in term of distance to the dest

						iWaitValue=iWaitValue*100000+list_neighbor[i].iWaitValue;//component metrics
						
						if (iBig<iWaitValue)
						{
								iBestOne=i;
								iBig=iWaitValue;
							
						}
						
					
				
				}

		
			}
		
	}//end of for
	
	if (iBestOne!=-1)
		{				if (EPIDEMIC)
							return iBestOne;
							   
						if (FULL_CONNECT==1)
								return iBestOne;

						if (GP_route_cache[iDest].iExpectedVal<=list_neighbor[iBestOne].iWaitValue && 
							GP_route_cache[iDest].iDistance !=-1 )	
							{
							//better next hop than me
							GP_route_cache[iDest].iExpectedVal= (MAX_SIZE_TTL-GP_route_cache[iDest].iDistance)*1000;
							return iBestOne;
							
							}
							
							//if (GP_route_cache[iDest].iDistance ==-1 )	
							//	return iBestOne;

						

		}
	else
		{
		
		
		
		}
	
	break;
	
	}//end of switch




return  iRet;

}

int IsIn_Right_Direction_NS(int iDest_addr,int iTest_GP,int iCode)
{
int iRet;
//////////////////////////
//iRet metrics assinged:
///////////////////////////
// -1:	wrong direction 
//	0: 	same group,but no route   
//	1:	same group, has route  or for request
//	2~:	has route and cross group
///////////////////////////   
int size_route;
int iPos_nb,iPos_me;	
int i,iTTL,iWaitValue;
int iBig,iBestOne;

iRet=-9990;
iPos_nb=iPos_me=-1;

if (FULL_CONNECT==1)
	return MAX_SIZE_TTL*500;//fixed valid level

if (iDest_addr==my_gpr_address)
	return MAX_SIZE_TTL*1000;//max level
size_route=	GP_route_cache[iDest_addr].size_route;

	if (GP_route_cache[iDest_addr].iDistance !=-1)
				iTTL=GP_route_cache[iDest_addr].iDistance;
	else 
				iTTL=MAX_SIZE_TTL;
		
		
	iWaitValue=iBig=iBestOne=-1;	
		
	for (i=0;i<MAX_SIZE_NODES;i++)
	{
	
		if (
			(list_neighbor[i].dest_addr==iDest_addr) &&
			(list_neighbor[i].iCode==iCode))//the neighbor echo ns
			{
		
			iWaitValue = list_neighbor[i].iWaitValue;
			
			//iWaitValue=iWaitValue+list_neighbor[i].iWaitValue;//component metrics
			
			//can be valued in term of distance to the dest
						if (iWaitValue!=-1&&iBig<iWaitValue)
						{
								iBestOne=i;
								iBig=iWaitValue;
						}
				}
		
		}//end of for
		
		
	if (size_route==0)
	{
													

			//filter:
			switch (iCode)
				{
										
				case ND_DATA:
							iRet= -9992;
				break;
										
				case ND_REQEST:
				if (iTest_GP==my_group_id)
					iRet= 1;
				else
					iRet=2;
				
				break;				
						
				case ND_REPLY:
																				
							sprintf(msg,"1)ND_REPLY,No route:metirc is %d\n",iTTL);
							GPR_message(msg,10);				
							return (MAX_SIZE_TTL-iTTL)*1000;

				break;
					
										
				
				}

	
	}
	else
	{

			//has route:
			iRet=-9991;

			for (i=0;i<size_route;i++)
			{
	
					if (GP_route_cache[iDest_addr].Gp_route[i] == iTest_GP )
					{	
						iPos_nb=i;
						}
					
					if (GP_route_cache[iDest_addr].Gp_route[i] == my_group_id )
					{	
						iPos_me=i;
					}
					
			 }//end of for
			

		
		
			//filter:
			switch (iCode)
				{
						case ND_DATA:
						//big endian
		
						if ( (iPos_me!=-1)&&(iPos_nb!=-1)&&(iPos_me>iPos_nb) )
							{
								//path is in right direction
													sprintf(msg,"2)DATA:metirc is %d\n",iTTL);
//													GPR_message(msg,10);
							iRet=( (iPos_me-iPos_nb+1)*MAX_SIZE_TTL-iTTL )*1000 +GP_route_cache[iDest_addr].iHistory*5+iBig/1000+1;													
							return iRet;
								
							}						
						if ( (iPos_me==iPos_nb)&&(iPos_nb!=-1) )
							{
																				

							iRet=(MAX_SIZE_TTL-iTTL)*1000 +GP_route_cache[iDest_addr].iHistory*5+iBig/1000+1;
							sprintf(msg,"3)DATA:TTL %d,metirc is %d\n",iTTL,iRet);
//							GPR_message(msg,10);								
							return iRet;
							
							}
												
						if ( (iPos_me!=-1)&&(iPos_nb!=-1)&&(iPos_me<iPos_nb) )
							{
									
								//path is in wrong direction 
								return  -1;
							}						
						sprintf(msg,"DATA:no direction infor,TTL(%d) to  %d\n",iTTL,iDest_addr);
//						GPR_message(msg,10);						
						iRet=(MAX_SIZE_TTL-iTTL)*1000+1;
						return iRet;
						
						break;
							
						case ND_REQEST:
						//all pass
						
							return 1;