#include "bot.h"

void Bot::Connect()
{
	bool tmp;
	#ifdef _WIN32
		tmp = SOCK_CREATEW();
	#else
		tmp = SOCK_CREATEL();
	#endif

	if(tmp == 1) Login();
}

void Bot::Disconnect()
{
	#ifdef _WIN32
		shutdown(sock, SD_BOTH);
		closesocket(sock);
		WSACleanup();
	#else
		close(sock);
	#endif

	printf("Socket Closed\n");
	Connected = false;
}

void Bot::Login()
{
	if(!strcmp(Client,"TAHC"))
	{
		Connected = true;
		////Send("%c%c%s\r\n%s\r\n/join %s\r\n", 0x03, 0x04, Username, Password, Channel);
		ABYTE(0x03);ABYTE(0x04);ASTRING(Username);ASTRING((char*)"\r\n");ASTRING(Password);ASTRING((char*)"\r\n");
		//Send("\x03\x04%s\r\n%s\r\n/join %s\r\n",  Username, Password, Channel);
		SOCK_HANDLERC();
	}
	else
	{
		send(sock,"\x01",1,0);
		SP_0x50();
		SOCK_HANDLERB();
	}
}

int Bot::Send(char *lpszFmt, ...)
{
	char szOutStr[256];
	va_list argptr;

	va_start(argptr, lpszFmt);
	vsprintf(szOutStr, lpszFmt, argptr);
	va_end(argptr);

	if (send(sock, szOutStr, strlen(szOutStr), 0) < 0)
		return 0;

	return 1;
}

bool Bot::SOCK_CREATEL()
{
	struct hostent *h;
	struct sockaddr_in their_addr;

	if ((h=gethostbyname(Server)) == NULL)
	{
		printf("gethostbyname error\n");
		return 0;
	}

	if ((sock = socket(AF_INET, SOCK_STREAM, 0)) == -1)
	{
		printf("socket error \n");
		return 0;
	}

	their_addr.sin_family = AF_INET;
	their_addr.sin_port = htons(6112);
	their_addr.sin_addr = *((struct in_addr *)h->h_addr);

	//bzero(&(their_addr.sin_zero), 8);

	if (connect(sock, (struct sockaddr *)&their_addr, sizeof(struct sockaddr)) == -1)
	{
		printf("connect error\n");
		return 0;
	}

	return 1;
}

bool Bot::SOCK_CREATEW()
{
#ifdef _WIN32
	int error = WSAStartup (0x0202, &wsaData); //0x202 = Version 2.2 | 0x101 = Version 1.1 :)

	if (error)
	{
		return 0;//return -1;
	}

	if (wsaData.wVersion != 0x0202)
	{
		WSACleanup();
		return 0;//return -2;
	}

	WSAStartup(MAKEWORD(1,1), &wsaData);
	sock = socket(AF_INET, SOCK_STREAM, 0);
	IRCAdd.sin_family = AF_INET;
	IRCAdd.sin_port = htons(6112);

	unsigned long addr = inet_addr(Server);
	if (addr == INADDR_NONE) {
		hostent* HE = gethostbyname(Server);
		if (!HE) {
			WSACleanup();
			return 0;//return -4;
		}
		addr = *((u_long*)HE->h_addr_list[0]);
	}

	IRCAdd.sin_addr.s_addr = addr;
	printf("Connecting to: %s:%u\n", Server, 6112);

	FD_SET fd_s;
	FD_ZERO(&fd_s);
	FD_SET(sock, &fd_s);

	error = connect(sock, (struct sockaddr *)&IRCAdd, sizeof(IRCAdd));
	if (error == SOCKET_ERROR)
	{
		error = select(0, NULL, &fd_s, NULL, 0);

		if (error == SOCKET_ERROR) {
			WSACleanup();
			return 0;//return -3;
		}
	}

	printf("Connected to %s!\n", Server);
	return 1;
#endif
}

void Bot::SOCK_HANDLERC()
{
	int numbytes;
	int nBufLen=0;
	int nBufPos=0;
	char stageBuf[2048];

	while(1)
	{
		int nNumToRead = 2048 - nBufLen - nBufPos;

		if (nNumToRead == 0)
		{
			memmove(stageBuf, stageBuf+nBufPos, nBufLen);
			nBufPos = 0;
			nNumToRead = 2048 - nBufLen;
		}

		numbytes = recv(sock, stageBuf + nBufPos + nBufLen, nNumToRead, 0);

		if (numbytes <= 0) return;

		nBufLen += numbytes;

		while (nBufLen > 0)
		{
			char *m = stageBuf + nBufPos;
			int nMsgLen = 0;

			while (nMsgLen < nBufLen)
			{
				if (m[nMsgLen] == '\n') break;
				nMsgLen++;
			}

			nMsgLen++;
			if (nMsgLen > nBufLen) break;
			m[nMsgLen - 1] = '\0';
			//if (isdigit(*m))
			CDispatch(m);
			nBufLen -= nMsgLen;
			nBufPos += nMsgLen;
		}

		if (!nBufLen) nBufPos = 0;
	}
}

void Bot::SOCK_HANDLERB()
{
	char recvbuf[32000];

	while (1)
	{
		char *recvbuf2 = recvbuf;
		int numbytes = recv(sock, recvbuf, sizeof(recvbuf), 0);


		if (!numbytes || numbytes == -1)
		{
			printf("\nSOCK_HANDLERB() ERROR\n");
			return;
		}

		while (numbytes >= 4)
		{
			if ((unsigned char)*recvbuf2 != (unsigned char)0xFF)
			{
				printf("\nNOT A 0xFF HHEADER\n");
				hexdump(recvbuf2);
				break;
			}

			int bnetlen = *(unsigned short *)(recvbuf2 + 2);
			if (bnetlen > numbytes)
			{
				//printf("\nexpecting %d more bytes\n", bnetlen-numbytes);

				if (recvbuf2 + numbytes >= recvbuf + sizeof(recvbuf))
				{
					memcpy(recvbuf, recvbuf2, numbytes);
					recvbuf2 = recvbuf;
				}

				if (bnetlen > numbytes)
				{
					int tmp = recv(sock, recvbuf2 + numbytes, sizeof(recvbuf) - (recvbuf2 - recvbuf) - numbytes, 0);

					if (!tmp || tmp == -1)
					{
						printf("\nSOCK_HANDLERB(2) ERROR\n");
						return;
					}

					numbytes += tmp;
				}
			}

			RP_HANDLER(recvbuf2[1], recvbuf2);
			recvbuf2 += bnetlen;
			numbytes -= bnetlen;
		}
	}
}