#include <windows.h>
#include <process.h>
//#include "TRACK.h"
#include "NET.h"

#define NET_IO_PORTBASE		(26000 + 0x20)


void NET_IO::OneFrameCall()
{
	ReadLoadData();
	RateControl();
}

static u32 volatile MustKill = 0;
unsigned __stdcall INPUT_THREAD(void *params)
{
	NET_IO *pNetIO;
	pNetIO = (NET_IO *)params;
	

	while (1)
	{
		if (MustKill)
		{
			MustKill--;
			_endthread();
		}
		pNetIO->ReadLoadData();
		Sleep(20) ; // QuiteSmall !! (but one million cycles!)
	}//*/
} // timeGetGetTime()


u32 NET_IO::NET_IsMyIp(u32 ulIP)
{
	u32 *pIPParser = MyulIPList;
	while (*pIPParser)
	{
		if (ulIP == *pIPParser) return 1;
		pIPParser++;
	}
	return 0;
}



int GivemeMyIP(char *IPADRESS,char *ComputerName,u32 *IPLIst)
{
	char ac[80];
	ac[0] = 0;
	if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR) {
		return 1;
	}
	strcpy(ComputerName,ac);
	struct hostent *phe = gethostbyname(ac);
	if (phe == 0) {
		return 1;
	}

	for (int i = 0; phe->h_addr_list[i] != 0; ++i) {
		struct in_addr addr;
		char IPADRESS2[256];
		memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr));
		strcpy(IPADRESS2, inet_ntoa(addr));
		if (i < 31)
			IPLIst[i] = ntohl ( inet_addr(IPADRESS2) ) ;
		if (!i) strcpy(IPADRESS,IPADRESS2);
	}
	return 0;
}



u32 NET_IO::SetNetPort(u32 port)
{
	if (MyPort != port)
	{
		if (WAIT_OBJECT_0 == WaitForSingleObject(InputData.AccesMutex, INFINITE))
		{
			if (WAIT_OBJECT_0 == WaitForSingleObject(OutputData.AccesMutex, INFINITE))
			{
				NET_Close();
				MyPort = port;
				NET_Open();
				ReleaseMutex(OutputData.AccesMutex);
			}
			ReleaseMutex(InputData.AccesMutex);
		}
	}
	if (NET_b_Open)
		return 0;
	else
		return 1;

}

void NET_IO::NET_Init(void)
{
	WORD	wVersionRequested;
	WSADATA wsaData;
	int		err;

	if(NET_b_Init) return;
	NET_SendToMe = 0;


	InTheNet = 0;
	//Randomize();
	MyPort = (NET_IO_PORTBASE);
	wVersionRequested = MAKEWORD(2, 2);

	err = WSAStartup(wVersionRequested, &wsaData);
	if(err != 0) return;

	memset(MyulIPList,0,sizeof(MyulIPList));
	GivemeMyIP(MyIP,MyComputerName,MyulIPList);
	MyulIP = MyulIPList[0];


	NET_b_Init = TRUE;

	NET_Open();

	InputData.THREAD_STACK.Reset();
	InputData.AccesMutex = CreateMutex(NULL, FALSE, "NET_InputMutex");
	for (u32 Counter = 0 ; Counter < MAXBUFFERS_IN ; Counter++)
	{
		InputData.THREAD_STACK.Add(&InputData.INPUT[Counter]);
	}
	OutputData.THREAD_STACK.Reset();
	OutputData.APPI_STACK.Reset();
	OutputData.AccesMutex = CreateMutex(NULL, FALSE, "NET_OutputMutex");
	for (u32 Counter = 0 ; Counter < MAXBUFFERS_OUT ; Counter++)
	{
		OutputData.APPI_STACK.Add(&OutputData.OUTPUT[Counter]);
	}
}
//*/
/*
 =======================================================================================================================
 =======================================================================================================================
 */
void NET_IO::NET_Open(void)
{
	/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
	int					err, option;
	ULONG				trueval;
	struct sockaddr_in	address;
	/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/

	if(!NET_b_Init) return;
	if(NET_b_Open) NET_Close();
	NET_b_Open = FALSE;

	NET_i_InSocket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
	if(NET_i_InSocket == -1) return;

	option = ~0;
	err = setsockopt(NET_i_InSocket, SOL_SOCKET, SO_BROADCAST, (char *) &option, sizeof(option));
	if(err == -1) return;

	memset(&address, 0, sizeof(address));
	address.sin_family = AF_INET;
	address.sin_addr.s_addr = htonl(INADDR_ANY);
	address.sin_port = htons(MyPort);
	err = bind(NET_i_InSocket, (const sockaddr *) &address, sizeof(address));
	if(err == -1) return;

	trueval = 1;
	ioctlsocket(NET_i_InSocket, FIONBIO, &trueval);

#define THREAD_STACK_SIZE (1024+sizeof(OneBuf))
	_beginthreadex( NULL , THREAD_STACK_SIZE , INPUT_THREAD , this , 0 , &InputthreadID );
	//SetThreadPriority((HANDLE)InputthreadID,THREAD_PRIORITY_HIGHEST);

	NET_b_Open = TRUE;
}

/*
 =======================================================================================================================
 =======================================================================================================================
 */
NET_IO::NET_IO()				
{
	memset(this, 0 , sizeof(NET_IO));
	RATE_UP = 10*1024;
	LastTimCheck = timeGetTime();
	RatingDT = 100;
};

/*
 =======================================================================================================================
 =======================================================================================================================
 */
void NET_IO::NET_Close(void)
{
	if(!NET_b_Init) return;
	if(!NET_b_Open) return;

	MustKill = 1;
	while (MustKill)
	{
	};
	//_beginthreadex( NULL , THREAD_STACK_SIZE , INPUT_THREAD , this , 0 , &InputthreadID );

	closesocket(NET_i_InSocket);
	NET_b_Open = FALSE;
};


/*
 =======================================================================================================================
 =======================================================================================================================
 */
void NTER_Error()
{
	/*~~~~~~~~~~~~~~~~~~*/
	int		err;
	char	*ErrString[] =
	{
		"",
		"",
		"",
		"",
		"WSAEINTR",
		"",
		"",
		"",
		"",
		"WSAEBADF",
		"",
		"",
		"",
		"WSAEACCES",
		"WSAEFAULT",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"WSAEINVAL",
		"",
		"WSAEMFILE",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"WSAEWOULDBLOCK",
		"WSAEINPROGRESS",
		"WSAEALREADY",
		"WSAENOTSOCK",
		"WSAEDESTADDRREQ",
		"WSAEMSGSIZE",
		"WSAEPROTOTYPE",
		"WSAENOPROTOOPT",
		"WSAEPROTONOSUPPORT",
		"WSAESOCKTNOSUPPORT",
		"WSAEOPNOTSUPP",
		"WSAEPFNOSUPPORT",
		"WSAEAFNOSUPPORT",
		"WSAEADDRINUSE",
		"WSAEADDRNOTAVAIL",
		"WSAENETDOWN",
		"WSAENETUNREACH",
		"WSAENETRESET",
		"WSAECONNABORTED",
		"WSAECONNRESET",
		"WSAENOBUFS",
		"WSAEISCONN",
		"WSAENOTCONN",
		"WSAESHUTDOWN",
		"WSAETOOMANYREFS",
		"WSAETIMEDOUT",
		"WSAECONNREFUSED",
		"WSAELOOP",
		"WSAENAMETOOLONG",
		"WSAEHOSTDOWN",
		"WSAEHOSTUNREACH",
		"WSAENOTEMPTY",
		"WSAEPROCLIM",
		"WSAEUSERS",
		"WSAEDQUOT",
		"WSAESTALE",
		"WSAEREMOTE",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"WSASYSNOTREADY",
		"WSAVERNOTSUPPORTED",
		"WSANOTINITIALISED",
		"",
		"",
		"",
		"",
		"",
		"",
		"",
		"WSAEDISCON",
		"WSAENOMORE",
		"WSAECANCELLED",
		"WSAEINVALIDPROCTABLE",
		"WSAEINVALIDPROVIDER",
		"WSAEPROVIDERFAILEDINIT",
		"WSASYSCALLFAILURE",
		"WSASERVICE_NOT_FOUND",
		"WSATYPE_NOT_FOUND",
		"WSA_E_NO_MORE",
		"WSA_E_CANCELLED",
		"WSAEREFUSED"
	};
	/*~~~~~~~~~~~~~~~~~~*/

	char *Error;
	//WSAEWOULDBLOCK == WSAGetLastError();
	//Error = ErrString[err];

	//if(err == WSAEWOULDBLOCK) return;

}