// Router.cpp : implementation file
//

#include "stdafx.h"
#include "MANET.h"

#include "Router.h"

/////////////////////////////
#include "RouterDialog.h"
#include "Link.h"
#include "Traffic.h"
#include "Packet.h"
/////////////////////////////

/////////////////////////////
#include <math.h>
/////////////////////////////


#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif

/////////////////////////////////////////////////////////////////////////////
// CRouter

CRouter::CRouter(CString Name,int X_axis,int Y_axis,int Rect_Length,int Rect_Width,int COVERAGE,int DELAY,int Buffer_Size,CString Image_Path,int type)
{
	this->Caption			=Name;
	this->X					=X_axis;
	this->Y					=Y_axis;
	this->RectLength		=Rect_Length;
	this->RectWidth			=Rect_Width;
	this->Rectangle.top		=Y;
	this->Rectangle.bottom	=Y+RectLength;
	this->Rectangle.left	=X;
	this->Rectangle.right	=X+RectWidth;
	this->Coverage			=COVERAGE;
	this->Delay				=DELAY;
	this->BufferSize		=Buffer_Size;
	this->ImagePath			=Image_Path;
	this->Type				=0;//0=Adhoc
	///////////////////////////////////
	this->created			=0;//not created
	this->RReqSeqNum		=0;
	this->RRepSeqNum		=0;
	this->DataSeqNum		=0;
	this->RReqExp			=-1;
	this->RRepExp			=-1;
	this->DataExp			=-1;
	this->ProcessDelay		=-1;//it means infinite!
	this->SendData			=FALSE;
	this->Clock				=0;
	///////////////////////////////////
}

CRouter::~CRouter()
{
	//CObArray	neighbors;
	//Nothing to do!

	//CObArray	generatedpackets;
	int ip;
	for(ip=0;ip<generatedpackets.GetSize();ip++)
		delete ((CPacket*)(generatedpackets[ip]));
	//packets.RemoveAll();

	//CObArray	traffics;
	int it;
	for(it=0;it<traffics.GetSize();it++)
		delete ((CTraffic*)(traffics[it]));
	//traffics.RemoveAll();

	//CObArray	links;
	int il;
	for(il=0;il<links.GetSize();il++)
		delete ((CLink*)(links[il]));
	//links.RemoveAll();
}


BEGIN_MESSAGE_MAP(CRouter, CButton)
	//{{AFX_MSG_MAP(CRouter)
	ON_WM_LBUTTONDOWN()
	ON_WM_LBUTTONUP()
	ON_WM_MOUSEMOVE()
	ON_CONTROL_REFLECT(BN_CLICKED, OnClicked)
	ON_WM_RBUTTONDOWN()
	ON_WM_RBUTTONUP()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CRouter message handlers

void CRouter::OnLButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	SetCapture();
	moved=0;
	LeftPreviousPosition=point;
	CButton::OnLButtonDown(nFlags, point);
}

void CRouter::OnLButtonUp(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	if(GetCapture()==this)
	{
		ReleaseCapture();
		if(moved)
		{
			int dx=point.x-LeftPreviousPosition.x;
			int dy=point.y-LeftPreviousPosition.y;
			Rectangle.bottom+=dy;
 			Rectangle.top+=dy;
 			Rectangle.left+=dx;
			Rectangle.right+=dx;
			this->RECT2XY(Rectangle);
 			MoveWindow(&Rectangle);	
			GetParent()->Invalidate();
		}
		else
		{
			this->OnClicked();
			//CRouterDialog rd;
			//rd.GetRouterData(this);
			//if(rd.DoModal()==IDOK)
			//rd.PushRouterData(this);
		}
	}
	CButton::OnLButtonUp(nFlags, point);
}

void CRouter::OnMouseMove(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	if((GetCapture()==this)&&(nFlags==MK_LBUTTON))
	{
		moved=1;
		int dx=point.x-LeftPreviousPosition.x;
		int dy=point.y-LeftPreviousPosition.y;
		Rectangle.bottom+=dy;
		Rectangle.top+=dy;
		Rectangle.left+=dx;
		Rectangle.right+=dx; 			
		this->RECT2XY(Rectangle);
		MoveWindow(&Rectangle);
		//GetParent()->Invalidate();
	}
	CButton::OnMouseMove(nFlags, point);
}


void CRouter::OnClicked() 
{
	// TODO: Add your control notification handler code here
	CRouterDialog rd;
	rd.GetRouterData(this);
	if(rd.DoModal()==IDOK)
		rd.PushRouterData(this);
}

void CRouter::Update(CString Name,int X_axis,int Y_axis,int Rect_Length,int Rect_Width,int COVERAGE,int DELAY,int Buffer_Size,CString Image_Path,int type)
{
	this->Caption			=Name;
	this->X					=X_axis;
	this->Y					=Y_axis;
	this->RectLength		=Rect_Length;
	this->RectWidth			=Rect_Width;
	this->Rectangle.top		=Y;
	this->Rectangle.bottom	=Y+RectLength;
	this->Rectangle.left	=X;
	this->Rectangle.right	=X+RectWidth;
	this->Coverage			=COVERAGE;
	this->Delay				=DELAY;
	this->BufferSize		=Buffer_Size;
	this->ImagePath			=Image_Path;
	this->Type				=type;
}

void CRouter::RECT2XY(RECT rectangle)
{
	this->X			=rectangle.left;
	this->Y			=rectangle.top;
	this->RectLength=rectangle.bottom-Y;
	this->RectWidth	=rectangle.right-X;
}

void CRouter::XY2RECT(long x,long y)
{
	this->Y					=y;
	this->X					=x;
	this->Rectangle.top		=y;
	this->Rectangle.left	=x;
	this->Rectangle.bottom	=Y+RectLength;
	this->Rectangle.right	=X+RectWidth;
}

void CRouter::UpdateRect()
{
	this->Rectangle.top		=Y;
	this->Rectangle.left	=X;
	this->Rectangle.bottom	=Y+RectLength;
	this->Rectangle.right	=X+RectWidth;	
}

//DEL void CRouter::OnRButtonDown(UINT nFlags, CPoint point) 
//DEL {
//DEL 	// TODO: Add your message handler code here and/or call default
//DEL 	FirstPosition=point;
//DEL 	CButton::OnRButtonDown(nFlags, point);
//DEL }

//DEL void CRouter::OnRButtonUp(UINT nFlags, CPoint point) 
//DEL {
//DEL 	// TODO: Add your message handler code here and/or call default
//DEL 	CButton::OnRButtonUp(nFlags, point);
//DEL /*	GetParentFrame()->ActivateFrame();
//DEL 	CPoint local = point;
//DEL 	ScreenToClient(&local);
//DEL 	UpdateWindow();
//DEL 	CMenu menu;
//DEL 	if (menu.LoadMenu(IDR_MENU_RMBVIEW))
//DEL 	{
//DEL 		CMenu* pPopup = menu.GetSubMenu(0);
//DEL 		ASSERT(pPopup != NULL);
//DEL 		pPopup->TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON,2*point.x-local.x,2*point.y-local.y,AfxGetMainWnd());
//DEL 	}*/
//DEL }

void CRouter::Serialize(CArchive& ar) 
{
	if (ar.IsStoring())
	{	// storing code
		ar<<Caption<<Rectangle<<Coverage<<Delay<<BufferSize<<ImagePath;
		//for(int i=0;i<links.GetSize();i++)
		//	((CLink*)(links[i]))->Serialize(ar);
	}
	else
	{	// loading code
		ar>>Caption>>Rectangle>>Coverage>>Delay>>BufferSize>>ImagePath;
		this->RECT2XY(Rectangle);
	}
}

void CRouter::OnRButtonDown(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default
	//CMANETView* pParent=
	//	this->GetParent()->OnRButtonDown(nFlags,point);
	//pParent->PreviousRouter=this;
	CButton::OnRButtonDown(nFlags, point);
}

void CRouter::OnRButtonUp(UINT nFlags, CPoint point) 
{
	// TODO: Add your message handler code here and/or call default

/*	if(RouterClick)
	{
		CMANETDoc* pDoc=GetDocument();
		ASSERT_VALID(pDoc);
		int routersize=pDoc->routers.GetSize();
		int i=0;
		if(routersize>1)// routersize must be >=2
		{
			while(i<routersize)
			{
				router=(CRouter*)(pDoc->routers[i]);
				if(	(router->Rectangle.left<CursorPosition.x)&&(router->Rectangle.right >CursorPosition.x)&&
					(router->Rectangle.top <CursorPosition.y)&&(router->Rectangle.bottom>CursorPosition.y)	)
					i=routersize+1;
				else
					i++;
			}
			if(i==routersize+1)
			{
				//RouterCounter++;
				PreviousPosition=CurrentPosition;
				CurrentPosition =point;
				//RouterCounter%=2;
				PreviousRouter=router;
				int i=0;
				while(i<routersize)
				{
					router=(CRouter*)(pDoc->routers[i]);
					if(	(router->Rectangle.left<CursorPosition.x)&&(router->Rectangle.right >CursorPosition.x)&&
						(router->Rectangle.top <CursorPosition.y)&&(router->Rectangle.bottom>CursorPosition.y)	)
						i=routersize+1;
					else
						i++;
				}
				if(i==routersize+1)
				{
					CurrentRouter=router;
					link=new CLink(PreviousRouter,CurrentRouter);
					pDoc->links.Add((CLink*)link);
				}
			}
		}
	}
	else
	{
		if((CurrentPosition.x==point.x)&&(CurrentPosition.y==point.y))
		{
			GetParentFrame()->ActivateFrame();
			this->CursorPosition=point;
			ScreenToClient(&CursorPosition);
			UpdateWindow();
			CMenu menu;
			if (menu.LoadMenu(IDR_MENU_RMBVIEW))
			{
				CMenu* pPopup = menu.GetSubMenu(0);
				ASSERT(pPopup != NULL);
				pPopup->TrackPopupMenu(TPM_LEFTALIGN|TPM_RIGHTBUTTON,point.x,point.y,AfxGetMainWnd());
			}
		}
	}
*/	CButton::OnRButtonUp(nFlags, point);
}

//DEL void CRouter::Draw(CDC *pDC)
//DEL {
//DEL 	rgb=RGB(0,255,0);//rgb=RGB(0,0,255);rgb=RGB(255,0,0);
//DEL 	CPen pen(PS_SOLID,1,rgb);
//DEL 	pDC->SelectObject(&pen);
//DEL 
//DEL 	if(datapacketsize=datapackets.GetSize())
//DEL 	{
//DEL 		for(int dpc=0;dpc<datapacketsize;i++)
//DEL 		{
//DEL 			if(!((CPacket*)(datapackets[dpc]))->SendData)
//DEL 			{
//DEL 				CPacket* datapacket=(CPacket*)(datapackets[dpc]);
//DEL 				start.x=(Rectangle.left+Rectangle.right)/2;
//DEL 				start.y=(Rectangle.top+Rectangle.bottom)/2;
//DEL 				end.x=
//DEL 			}
//DEL 		}
//DEL 	}
//DEL 
//DEL 		while((dpsc<datapacketsize)&&(((CPacket*)(datapackets[dpsc]))->SendData))
//DEL 		{
//DEL 			if(!((CPacket*)(datapackets[dpsc]))->Timeout--)
//DEL 			{
//DEL 				CPacket* datapacket=(CPacket*)(datapackets[dpsc]);
//DEL 				datapacket->Timeout=(datapacket->Stop-datapacket->Start)*3;
//DEL 				int sti=GetTableIndexToDest(datapacket);
//DEL 				if(sti!=-1)
//DEL 				{
//DEL 					int n=GetBestPathToSource(datapacket,(CTable*)(tables[sti]));
//DEL 					if(n!=-1)
//DEL 						((CLink*)(links[n]))->Upload(datapacket,this);
//DEL 				}
//DEL 			}
//DEL 			dpsc++;
//DEL 		}
//DEL 	}


///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

CPacket* CRouter::GenRReq(int protocol, CRouter *destination)//CTraffic* tr)
{
	Packet=new CPacket(rand(),0/*type=RReq*/,protocol,Caption,destination->Caption,++RReqSeqNum,RReqExp);
	return Packet;
}

CPacket* CRouter::GenRRep(CPacket* packet)//int protocol, CRouter *source, CRouter *destination)
{
	Packet=new CPacket(packet->ID,1/*type=RRep*/,packet->Protocol,Caption,packet->Source,++RRepSeqNum,RRepExp);
	return Packet;
}

CPacket* CRouter::GenDataPacket(CPacket *packet)
{
	Packet=new CPacket(packet->ID,2/*type=Data*/,packet->Protocol,Caption,packet->Source,++DataSeqNum,DataExp);
	return Packet;
}

CPacket* CRouter::GenAckPacket(CPacket* packet)
{
	Packet=new CPacket(packet->ID,3/*type=Ack*/,packet->Protocol,packet->Destination,packet->Source,packet->SeqNum,packet->Expiration);
	return Packet;
}

void CRouter::Broadcast(CPacket* packet)
{
	if(linksize=links.GetSize())
		for(int i=0;i<linksize;i++)
		//	if( ((CRouter*)(neighbors[i]))->Caption != packetuploaders[0] )
				((CLink*)(links[i]))->Upload(packet,this);
}

void CRouter::Receive()
{
	if(linksize=links.GetSize())
		for(int l=0;l<linksize;l++)
			if(((CLink*)(links[l]))->Transmit(this))
				if((Packet=((CLink*)(links[l]))->Download(this))!=NULL)
					if(packetrepetition=IsProcessed((CRouter*)(neighbors[l]),Packet))//Already Processed?
					{
						processedneighbors.Add((CRouter*)(neighbors[l]));
						packetuploaders.Add(((CRouter*)(neighbors[l]))->Caption);
						//packetuploader=((CRouter*)(neighbors[l]))->Caption;
						packetrepetitions.Add(packetrepetition);
						if(!receivedpackets.Add((CPacket*)Packet))
							ProcessDelay=GetProcessDelay(Packet);
						/////////////////////////
						GetParent()->Invalidate();
						/////////////////////////
					}
}

int CRouter::GetProcessDelay(CPacket* packet)
{
	if(packet->Type==0)			//Route Request Packet *3
	{
		return 3*Delay;
	}
	else if(packet->Type==1)	//Route Reply Packet *3
	{
		return 3*Delay;
	}
	else if(packet->Type==2)	//Data Packet *1
	{
		return Delay;
	}
	else if(packet->Type==3)	//Ack Packet *1
	{
		return Delay;
	}
	else
		return 0;
}

void CRouter::SparkTraffic()
{
	if(trafficsize=traffics.GetSize())
	{
		int t=0;
		while(t<trafficsize)
		{
			if( ((CTraffic*)(traffics[t]))->Start )
			{
				((CTraffic*)(traffics[t]))->Start--;
				t++;
			}
			else
			{
				Packet=GenRReq(((CTraffic*)(traffics[t]))->Protocol,((CTraffic*)(traffics[t]))->Destination);
				generatedpackets.Add((CPacket*)Packet);
				Packet->Start=Clock;					//Save current clock of router
				Broadcast(Packet);
				delete (CTraffic*)(traffics[t]);
				traffics.RemoveAt(t);
				trafficsize--;
			}
		}
	}
	if(datapacketsize=datapackets.GetSize())
	{
		int dpsc=0;
		while((dpsc<datapacketsize)&&(((CPacket*)(datapackets[dpsc]))->SendData))
		{
			if(!((CPacket*)(datapackets[dpsc]))->Timeout--)
			{
				CPacket* datapacket=(CPacket*)(datapackets[dpsc]);
				datapacket->Timeout=(datapacket->Stop-datapacket->Start)*2;
				int sti=GetTableIndexToDest(datapacket);
				if(sti!=-1)
				{
					datapacket->ChangePath=TRUE;
					int n=GetNextHop(datapacket,(CTable*)(tables[sti]));
					if(n!=-1)
						((CLink*)(links[n]))->Upload(datapacket,this);
				}
			}
			dpsc++;
		}
	}
}

void CRouter::tick()
{
	Receive();//Receive Packets
	Process();//Process Packets
	SparkTraffic();//Spark Traffics
	Clock++;
}

//DEL void CRouter::SendDataSchedule()
//DEL {
//DEL 	int n=GetBestPathToSource(packet,(CTable*)(tables[sti]));
//DEL 	if(n!=-1)
//DEL 		((CLink*)(links[n]))->Upload(Packet,this);
//DEL }

void CRouter::Process()
{
	if(receivedpackets.GetSize())
	{
		if(ProcessDelay)
			ProcessDelay--;//decrease ProcessDelay until it reaches ZERO
		else //ProcessDelay==0
		{
			Packet=(CPacket*)(receivedpackets[0]);		//Get Current Packet To Be To Process

			if(Packet->Type==0)							//Route Request Packet Processing
			{
				ProcessRReqPacket(Packet);
				processedpackets.Add(Packet);			//Add Current Packet to processedpackets Array
			}
			else if(Packet->Type==1)					//Route Reply Packet Processing
			{
				ProcessRRepPacket(Packet);
				processedpackets.Add(Packet);			//Add Current Packet to processedpackets Array
			}
			else if(Packet->Type==2)					//Data Packet Processing
			{
				ProcessDataPacket(Packet);
				//processedpackets.Add(Packet);			//Add Current Packet to processedpackets Array
			}
			else if(Packet->Type==3)					//Ack Packet Processing
			{
				ProcessAckPacket(Packet);
				//processedpackets.Add(Packet);
			}
			else
			{
				//ProcessAnyPacket(Packet);
				//processedpackets.Add(Packet);
			}
			/////////////////Last Modifications////////////////////////////////
			receivedpackets.RemoveAt(0);				//Remove Current Packet from packets Array
			packetuploaders.RemoveAt(0);				//Remove Current Packet-Uploader from packetuploaders Array
			packetrepetitions.RemoveAt(0);				//Remove Current Packet Repetition Type
			if(receivedpackets.GetSize())				//Set Next Process Delay
				ProcessDelay=((CPacket*)(receivedpackets[0]))->ProcessDelay;
			else
				ProcessDelay=-1;						//infinite
			///////////////////////////////////////////////////////////////////
		}
	}
}

void CRouter::ProcessRReqPacket(CPacket* packet)
{
	if(packet->Protocol==0)
		ProcessRReqPacket0(packet);
	else if(packet->Protocol==1)
		ProcessRReqPacket1(packet);
	else if(packet->Protocol==2)
		ProcessRReqPacket2(packet);
}

void CRouter::ProcessRRepPacket(CPacket* packet)
{
	if(packet->Protocol==0)
		ProcessRRepPacket0(packet);
	else if(packet->Protocol==1)
		ProcessRRepPacket1(packet);
	else if(packet->Protocol==2)
		ProcessRRepPacket2(packet);
}

void CRouter::ProcessDataPacket(CPacket* packet)
{
	if(!this->Type)
	{
		if(packet->Protocol==0)
			ProcessDataPacket0(packet);
		else if(packet->Protocol==1)
			ProcessDataPacket1(packet);
		else if(packet->Protocol==2)
			ProcessDataPacket2(packet);
	}
}

void CRouter::ProcessAckPacket(CPacket* packet)
{
	if(!this->Type)
	{
		if(packet->Protocol==0)
			ProcessAckPacket0(packet);
		else if(packet->Protocol==1)
			ProcessAckPacket1(packet);
		else if(packet->Protocol==2)
			ProcessAckPacket2(packet);
	}
}

/// must be edited
BYTE CRouter::IsProcessed(CRouter* neighbor, CPacket* packet)
{
	if(packet->Source!=Caption)
	{
		if(processedpacketsize=processedpackets.GetSize())
		{
			int ppc=0;
			while((ppc<processedpacketsize)&&(packet!=(CPacket*)(processedpackets[ppc])))
				ppc++;
			if(ppc<processedpacketsize)
			{
				if(neighbor==(CRouter*)(processedneighbors[ppc]))
					return 0;
				else
					return 1;
			}
		}
		if(receivedpacketsize=receivedpackets.GetSize())
		{
			int rpc=0;
			while((rpc<receivedpacketsize)&&(packet!=(CPacket*)(receivedpackets[rpc])))
				rpc++;
			if(rpc<receivedpacketsize)
			{
				if(neighbor->Caption==packetuploaders[rpc])
					return 0;
				else
					return 1;
			}
		}
		return 2;//new packet
	}
	else
		return 0;//own packet
}

/*BYTE CRouter::IsBroadcast(CPacket* packet)
{
	if(packet->Source!=Caption)
	{
		if(processedpacketsize=processedpackets.GetSize())
		{
			int ppc=0;
			while((ppc<processedpacketsize)&&(packet!=(CPacket*)(processedpackets[ppc])))
				ppc++;
			if(ppc<processedpacketsize)
			{
				if(neighbor==(CRouter*)(processedneighbors[ppc]))
					return 0;//Repeated Packet from Repeated Neighbor
				else
					return 1;//Repeated Packet Only
			}
			else
				return 2;//new packet
		}
		else
			return 2;//new packet
	}
	else
		return 0;//own packet
}*/

inline int CRouter::GetNextHop(CPacket* packet,CTable *table)
{
	if(pathsize=table->paths.GetSize())
	{//Get the Destine-Table Matched With Packet!
		if(packet->ChangePath)//Policy to Change Previous Path
		{
			if(!table->Round)
				packet->ChangePath=0;
			table->ChangePath();
		}
		//while((psc<pathsize)&&(!((CPath*)(table->paths[psc]))->SizeCount))
		//	psc++;
		if(neighborsize=neighbors.GetSize())
		{//Get the Firsthop-Neighbor Matched With Packet!
			int nsc=0;
			while((nsc<neighborsize)&&(((CPath*)(table->paths[table->Index]))->FirstHop!=((CRouter*)(neighbors[nsc]))->Caption))
				nsc++;
			if(nsc<neighborsize)
			{//Send Packet to Firsthop Neighbor = Upload to proper link
				//((CPath*)(table->paths[psc]))->SizeCount--;
				return nsc;
			}
			else
			{
				delete (CPath*)(table->paths[table->Index]);
				table->paths.RemoveAt(table->Index);
				table->Index--;
				//table->ChangePath();
				return GetNextHop(packet,table);
			}
		}
		else
			return -1;
	}
	else
		return -1;
}

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessDataPacket0(CPacket* packet)//ELMAR
{
	//if(LoopFree(p)){
	if(packet->Destination!=Caption)
	{
		if(tablesize=tables.GetSize())
		{//For Each Destination We have Some Paths
			int tsc=0;
			while((tsc<tablesize)&&(((CTable*)(tables[tsc]))->Destination!=packet->Source))
				tsc++;
			if(tsc<tablesize)
			{
				Table=(CTable*)(tables[tsc]);
				if(pathsize=Table->paths.GetSize())
				{//Get the Destine-Table Matched With Packet!
					int psc=0;
					while((psc<pathsize)&&(((CPath*)(Table->paths[psc]))->FirstHop!=packetuploaders[0]))
						psc++;
					Table->Index=psc;
				}
			}
			tsc=0;
			while((tsc<tablesize)&&(((CTable*)(tables[tsc]))->Destination!=packet->Destination))
				tsc++;
			if((tsc<tablesize))//&&(pathsize=((CTable*)(tables[tsc]))->paths.GetSize()))
			{//Get the Destine-Table Matched With Packet!
				//int psc=0;
				//while((psc<pathsize)&&(!((CPath*)(((CTable*)(tables[tsc]))->paths[psc]))->SizeCount))
				//	psc++;
				//if((psc<pathsize)&&(neighborsize=neighbors.GetSize()))
				//{//Get the Firsthop-Neighbor Matched With Packet!
					//int nsc=0;
					int nsc=GetNextHop(packet,(CTable*)(tables[tsc]));
					//while((nsc<neighborsize)&&(((CPath*)(((CTable*)(tables[tsc]))->paths[psc]))->FirstHop!=((CRouter*)(neighbors[nsc]))->Caption))
					//	nsc++;
					//if(nsc<neighborsize)
					//{//Send Packet to Firsthop Neighbor = Upload to proper link
					//	if(packet->ChangePath)//Policy to Change Previous Path
					//		((CPath*)(((CTable*)(tables[tsc]))->paths[psc]))->SizeCount--;
						((CLink*)(links[nsc]))->Upload(packet,this);
					//}
				//}
			}
		}
	}
	else
	{
		if(neighborsize=neighbors.GetSize())
		{
			int nsc=0;
			while((nsc<neighborsize)&&(((CRouter*)(neighbors[nsc]))->Caption!=packetuploaders[0]))
				nsc++;
			if(nsc<neighborsize)
			{
				Packet=GenAckPacket(packet);
				generatedpackets.Add((CPacket*)Packet);
				((CLink*)(links[nsc]))->Upload(Packet,this);
			}
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessAckPacket0(CPacket* packet)
{
	if(packet->Destination!=Caption)
	{
		if(tablesize=tables.GetSize())
		{//For Each Destination We have Some Paths
			int tsc=0;
			while((tsc<tablesize)&&(((CTable*)(tables[tsc]))->Destination!=packet->Destination))
				tsc++;
			if((tsc<tablesize)&&(pathsize=((CTable*)(tables[tsc]))->paths.GetSize()))
			{//Get the Destine-Table Matched With Packet!
				Table=(CTable*)(tables[tsc]);
				//int psc=0;
				//while((psc<pathsize)&&(!((CPath*)(((CTable*)(tables[tsc]))->paths[psc]))->SizeCount))
				//	psc++;
				if((Table->Index<(unsigned)pathsize)&&(neighborsize=neighbors.GetSize()))
				{//Get the Firsthop-Neighbor Matched With Packet!
					int nsc=0;
					//while((nsc<neighborsize)&&(((CPath*)(((CTable*)(tables[tsc]))->paths[psc]))->FirstHop!=((CRouter*)(neighbors[nsc]))->Caption))
					while((nsc<neighborsize)&&(((CPath*)(Table->paths[Table->Index]))->FirstHop!=((CRouter*)(neighbors[nsc]))->Caption))
						nsc++;
					if(nsc<neighborsize)
					{//Send Packet to Firsthop Neighbor = Upload to proper link
						//if(packet->ChangePath)//Policy to Change Previous Path
						//	((CPath*)(((CTable*)(tables[tsc]))->paths[psc]))->SizeCount--;
						((CLink*)(links[nsc]))->Upload(packet,this);
					}
				}
			}
		}
	}
	else
	{
		if(datapacketsize=datapackets.GetSize())
		{
			int dpsc=0;
			while((dpsc<datapacketsize)&&(packet->ID!=((CPacket*)(datapackets[dpsc]))->ID))
				dpsc++;
			if(dpsc<datapacketsize)
			{
				CPacket* datapacket=(CPacket*)(datapackets[dpsc]);
				datapacket->Stop=Clock;
				//if(datapacket->Stop-datapacket->Start)
				datapacket->SendData=FALSE;
			}
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

inline int CRouter::GetTableIndexToDest(CPacket* packet)
{
	if(tablesize=tables.GetSize())
	{
		int tsc=0;
		while((tsc<tablesize)&&(((CTable*)(tables[tsc]))->Destination!=packet->Destination))
			tsc++;
		if(tsc<tablesize)
			return tsc;
		else
			return -1;
	}
	else
		return -1;
}

inline int CRouter::GetTableIndexToSource(CPacket* packet)
{
	if(tablesize=tables.GetSize())
	{
		int tsc=0;
		while((tsc<tablesize)&&(((CTable*)(tables[tsc]))->Destination!=packet->Source))
			tsc++;
		if(tsc<tablesize)
			return tsc;
		else
			return -1;
	}
	else
		return -1;
}

inline void CRouter::GetTableIndexToSourceAndDest(CPacket* packet, int *stc, int *dtc)
{
	int tsc=0;
	*dtc=-1;
	*stc=-1;
	if(tablesize=tables.GetSize())
	{
		while((tsc<tablesize)&&((*dtc<0)||(*stc<0)))
		{
			if(((CTable*)(tables[tsc]))->Destination==packet->Destination)
				*dtc=tsc;
			if(((CTable*)(tables[tsc]))->Destination==packet->Source     )
				*stc=tsc;
			tsc++;
		}
	}
}

void CRouter::ProcessRReqPacket0(CPacket* packet)//ELMAR
{
	if(packet->Destination!=Caption)
	{
		if(tablesize=tables.GetSize())//For Each Source and Destination May it be We have Some Paths
		{
			int t=0;
			int td=-1,ts=-1;
			while((t<tablesize)&&((td<0)||(ts<0)))
			{
				if(((CTable*)(tables[t]))->Destination==packet->Destination)
					td=t;
				if(((CTable*)(tables[t]))->Destination==packet->Source     )
					ts=t;
				t++;
			}
			if(ts!=-1)
			{
				if(pathsize=((CTable*)(tables[ts]))->paths.GetSize())
				{//Get the Destine-Table Matched With Packet!
					int psc=0;
					while((psc<pathsize)&&(((CPath*)(((CTable*)(tables[ts]))->paths[psc]))->FirstHop!=packetuploaders[0]))
						psc++;
					if(psc<pathsize)//Get the FirstHop Matched
					{
						packet->Uploader=packetuploaders[0];
						((CPath*)(((CTable*)(tables[ts]))->paths[psc]))->Update(packet);
					}
					else
					{
						packet->Uploader=packetuploaders[0];
						//((CTable*)(tables[ts]))->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
						((CTable*)(tables[ts]))->SetPathByPacket(packet);
					}
				}
				else
				{
					packet->Uploader=packetuploaders[0];
					//((CTable*)(tables[ts]))->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
					((CTable*)(tables[ts]))->SetPathByPacket(packet);
				}
			}
			else
			{//No table for source
				if(packet->Source!=Caption)
				{
					Table=new CTable(packet->Source);
					tables.Add(Table);
					packet->Uploader=packetuploaders[0];
					Table->SetPathByPacket(packet);
					//Table->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
					//Broadcast(packet);
				}
			}
			if(td!=-1)//Is there any path to destination node?
			{
				//int ts=GetTableIndexToSource(packet);
				if( ((CTable*)(tables[td]))->paths.GetSize()==neighbors.GetSize() )
				{
					if(packetrepetitions[0]==2)
					{
						Packet=GenRRep(packet);
						generatedpackets.Add((CPacket*)Packet);
						if(ts!=-1)
						{
							int n=GetNextHop(packet,(CTable*)(tables[ts]));
							if(n!=-1)
								((CLink*)(links[n]))->Upload(Packet,this);
							else
								Broadcast(Packet);
						}
						else
							Broadcast(Packet);
					}
				}
				else//destination paths are not clear!
					if(packetrepetitions[0]==2)
						Broadcast(packet);
			}
			else//unknown destination
				if(packetrepetitions[0]==2)
					Broadcast(packet);
		}
		else
		{//There is no Table
			if(packet->Source!=Caption)
			{
				Table=new CTable(packet->Source);
				tables.Add(Table);
				packet->Uploader=packetuploaders[0];
				Table->SetPathByPacket(packet);
				//Table->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
				Broadcast(packet);
			}
		}
	}
	else//packet->Destination==this->Caption
	{
		int sti=GetTableIndexToSource(packet);
		if((sti!=-1)&&(pathsize=((CTable*)(tables[sti]))->paths.GetSize()))
		{//Get the Destine-Table Matched With Packet!
			int psc=0;
			while((psc<pathsize)&&(((CPath*)(((CTable*)(tables[sti]))->paths[psc]))->FirstHop!=packetuploaders[0]))
				psc++;
			if(psc<pathsize)//Get the FirstHop Matched
			{
				packet->Uploader=packetuploaders[0];
				((CPath*)(((CTable*)(tables[sti]))->paths[psc]))->Update(packet);
			}
			else
			{
				//((CTable*)(tables[sti]))->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
				packet->Uploader=packetuploaders[0];
				((CTable*)(tables[sti]))->SetPathByPacket(packet);
			}
		}
		else
		{//No table to source exists!
			Table=new CTable(packet->Source);
			tables.Add(Table);
			packet->Uploader=packetuploaders[0];
			Table->SetPathByPacket(packet);
			//Table->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
		}

		//if(generatedpacketsize=generatedpackets.GetSize())//new rreq packet
		packetrepetition=packetrepetitions[0];
		if(packetrepetitions[0]==2)//new rreq packet
		{
			//int gpc=0;
			//while((gpc<generatedpacketsize)&&(((CPacket*)(generatedpackets[gpc]))->ID!=packet->ID))
			//	gpc++;
			//if(gpc==generatedpacketsize)
			{
				Packet=GenRRep(packet);
				generatedpackets.Add((CPacket*)Packet);
				if(sti!=-1)
				{
					int n=GetNextHop(packet,(CTable*)(tables[sti]));
					((CLink*)(links[n]))->Upload(Packet,this);
				}
				else
					Broadcast(Packet);
			}
		}
	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessRRepPacket0(CPacket* packet)
{
	if(packet->Destination!=Caption)
	{
		if(tablesize=tables.GetSize())//For Each Destination We have Some Paths
		{
			int t=0;
			int td=-1,ts=-1;
			while((t<tablesize)&&((td<0)||(ts<0)))
			{
				if(((CTable*)(tables[t]))->Destination==packet->Destination)
					td=t;
				if(((CTable*)(tables[t]))->Destination==packet->Source     )
					ts=t;
				t++;
			}
			if(td!=-1)//Is there any path to destination node?
			{
				int n=GetNextHop(packet,(CTable*)(tables[td]));
				if(n!=-1)
					((CLink*)(links[n]))->Upload(packet,this);
			}
			else//unknown destination
				if(packetrepetitions[0]==2)
					Broadcast(packet);
			if(ts!=-1)
			{
				if(pathsize=((CTable*)(tables[ts]))->paths.GetSize())
				{//Get the Destine-Table Matched With Packet!
					int psc=0;
					while((psc<pathsize)&&(((CPath*)(((CTable*)(tables[ts]))->paths[psc]))->FirstHop!=packetuploaders[0]))
						psc++;
					if(psc<pathsize)
					{//Get the FirstHop Matched
						packet->Uploader=packetuploaders[0];
						((CPath*)(((CTable*)(tables[ts]))->paths[psc]))->Update(packet);
					}
					else
					{
						//((CTable*)(tables[ts]))->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
						packet->Uploader=packetuploaders[0];
						((CTable*)(tables[ts]))->SetPathByPacket(packet);
					}
				}
				else
				{
					packet->Uploader=packetuploaders[0];
					((CTable*)(tables[ts]))->SetPathByPacket(packet);
					//((CTable*)(tables[ts]))->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
				}
			}
			else
			{//No table for source
				Table=new CTable(packet->Source);
				tables.Add(Table);
				packet->Uploader=packetuploaders[0];
				Table->SetPathByPacket(packet);
				//Table->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
			}
		}
		else
		{//There is no Table
			Table=new CTable(packet->Source);
			tables.Add(Table);
			packet->Uploader=packetuploaders[0];
			Table->SetPathByPacket(packet);
			//Table->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
			if(packetrepetitions[0]==2)
				Broadcast(packet);
		}
	}
	else//packet->Destination==this->Caption
	{
		int sti=GetTableIndexToSource(packet);
		if(sti!=-1)
		{//Get the Destine-Table Matched With Packet!
			int psc=0;
			while((psc<pathsize)&&(((CPath*)(((CTable*)(tables[sti]))->paths[psc]))->FirstHop!=packetuploaders[0]))
				psc++;
			if(psc<pathsize)//Get the FirstHop Matched
			{
				packet->Uploader=packetuploaders[0];
				((CPath*)(((CTable*)(tables[sti]))->paths[psc]))->Update(packet);
			}
			else
			{
				packet->Uploader=packetuploaders[0];
				((CTable*)(tables[sti]))->SetPathByPacket(packet);
				//((CTable*)(tables[sti]))->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
			}
		}
		else
		{//No table to source exists!
			Table=new CTable(packet->Source);
			tables.Add(Table);
			packet->Uploader=packetuploaders[0];
			Table->SetPathByPacket(packet);
			//Table->SetPath(packetuploaders[0],packet->TickCount,packet->HopCount,packet->SizeCount);
			sti=tables.GetSize()-1;
		}
		if(generatedpacketsize=generatedpackets.GetSize())
		{
			int gpsc=0;
			while	(	(gpsc<generatedpacketsize)&&
							(
							(packet->ID!=((CPacket*)(generatedpackets[gpsc]))->ID)||
							(((CPacket*)(generatedpackets[gpsc]))->SendData)
							)
					)
				gpsc++;
			if(gpsc<generatedpacketsize)
			{
				CPacket* rreq=(CPacket*)(generatedpackets[gpsc]);
				rreq->SendData=TRUE;
				rreq->Stop=Clock;
				rreq->Timeout=(rreq->Stop-rreq->Start)*2;
				Packet=GenDataPacket(packet);		//Generate Data Packet
				datapackets.Add((CPacket*)Packet);
				Packet->Start=rreq->Start;
				Packet->Stop=rreq->Stop;
				Packet->Timeout=(rreq->Stop-rreq->Start)*2;
				Packet->SendData=TRUE;
				int n=GetNextHop(packet,(CTable*)(tables[sti]));
				if(n!=-1)
					((CLink*)(links[n]))->Upload(Packet,this);
			}
		}

	}
}

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessRReqPacket1(CPacket* packet)//AODV
{

}

///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessRRepPacket1(CPacket* packet)//AODV
{

}

///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessDataPacket1(CPacket* packet)//AODV
{

}

///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessAckPacket1(CPacket* packet)//AODV
{

}

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessRReqPacket2(CPacket* packet)//DSR
{

}

///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessRRepPacket2(CPacket* packet)//DSR
{

}

///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessDataPacket2(CPacket* packet)//DSR
{

}

///////////////////////////////////////////////////////////////////////////////////////////////////

void CRouter::ProcessAckPacket2(CPacket* packet)//DSR
{

}

///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////