//#include "CSocketHandler.h"
void CRealmHandler::CommandClose(SOCKETINFO* sockinfo)
{
	assert(sockinfo);
	if (CloseSocket(sockinfo->ListID) == -1)
		LOG("[-] CloseSocket failed");
	else
		LOG("[+] Close Succesfull");
}

unsigned int CloseSocket(unsigned int ListIndex) { return RemoveSocketFromList(ListIndex);

CSocketHandler::CSocketHandler()
{
	ListCount = 0;
}

CSocketHandler::~CSocketHandler()
{
	while (SocketsList.size() > 0)
	{
		SocketsList.pop_back();
	}
}

unsigned int CSocketHandler::AddSocketToList(SOCKETINFO sinfo)
{
	sinfo.ListID = ++ListCount;
	SocketsList.push_back(sinfo);
	return ListCount;
}

unsigned int CSocketHandler::RemoveSocketFromList(unsigned int ListIndex)
{
	if (SocketsList.empty())
		return -1;

	for (SOCKETLIST::iterator it = SocketsList.begin(); it != SocketsList.end(); ++it)
	{
		if (it->ListID == ListIndex)
		{
			RemoveSocketFromList(it->ListID);
			SocketsList.erase(it);
			return --ListCount;
		}
	}
	return -1;
}

SOCKETINFO* CSocketHandler::GetSocketInfo(unsigned int ListID)
{
	if (SocketsList.empty())
		return 0;

	for (SOCKETLIST::iterator it = SocketsList.begin(); it != SocketsList.end(); ++it)
	{
		if (it->ListID == ListID)
			return it->GetInstance();
	}
	return 0;
}

unsigned int CSocketHandler::ConnectToHost(char* Host, unsigned short Port)
{
	assert(Host);
	if ((Port < 1) || (Port > 65535))
		return -1;

	SOCKETINFO sockinfo;
	sockinfo.IP = Host;
	sockinfo.Port = Port;
	sockinfo.HostName = Host;
	sockinfo.RealIP = sockinfo.IP;

	WSAData wsadata;
	if (WSAStartup(MAKEWORD(2,2), &wsadata) != 0)
	{
		LOG("[-] WSAStartup() failed: %s (%u).", GetSocketError(), WSAGetLastError());
		return CONNECT_ERROR;
	}
	LOG("[*] WSAStartup initialized.");

	sockinfo.sock = socket(AF_INET, SOCK_STREAM, 0);
	if (sockinfo.sock == INVALID_SOCKET)
	{	
		LOG("[-] socket() failed: %s (%u).", GetSocketError(), WSAGetLastError());
		WSACleanup();
		return CONNECT_ERROR;
	}
	LOG("[*] socket created.");

	hostent *remoteHost;
	if (isalpha((int)Host[0]))	// "ftp.google.nl"
	{
		remoteHost = gethostbyname(sockinfo.IP);
		if (remoteHost)
		{
			sockinfo.RealIP = inet_ntoa(*(in_addr *)*remoteHost->h_addr_list);
			sockinfo.HostName = remoteHost->h_name;
			LOG("[*] Host %s is %s (%s).", sockinfo.IP, sockinfo.RealIP, sockinfo.HostName);
		}
		else
			LOG("[-] Could not retrieve real IP of host %s.", sockinfo.HostName);
	}
	else	// "127.0.0.1"
	{
		unsigned int addr = inet_addr(sockinfo.IP);
		remoteHost = gethostbyaddr((char*)&addr, 4, AF_INET);
		if (remoteHost)
		{
			sockinfo.HostName = remoteHost->h_name;
			LOG("[*] Hostname of %s is %s.", sockinfo.IP, sockinfo.HostName);
		}
		else
			LOG("[-] Could not retrieve hostname of %s.", sockinfo.IP);
	}

	sockinfo.sock_addr.sin_addr.s_addr = inet_addr(sockinfo.RealIP);
	sockinfo.sock_addr.sin_family = AF_INET;
	sockinfo.sock_addr.sin_port = htons(sockinfo.Port);
	if (connect(sockinfo.sock, (sockaddr*)&sockinfo.sock_addr, sizeof(SOCKADDR_IN)) == SOCKET_ERROR)
	{
		LOG("[-] Connecting to %s:%d failed.", sockinfo.IP, sockinfo.Port);
		LOG("[-] %s (%u).", GetSocketError(), WSAGetLastError());
		WSACleanup();
		return CONNECT_ERROR;
	}
	LOG("[*] Connected to %s:%d.\r\n", sockinfo.IP, sockinfo.Port);
	return AddSocketToList(sockinfo);
}

bool CSocketHandler::HandleSocket(unsigned int SocketListID, bool AllowUserInput)
{
	SOCKETINFO* socketinfo = GetSocketInfo(SocketListID);
	if (!socketinfo)
	{
		LOG("[-] GetSocketInfo() failed (%u).", GetLastError());
		return false;
	}

	if (AllowUserInput)
	{
		SocketHandlerStruct socketstruct;
		socketstruct.SocketListID = socketinfo->ListID;
		memcpy(&socketstruct.SocketHandler, this, sizeof(CSocketHandler));
		socketinfo->hInputThread = CreateThread(0, 0, (LPTHREAD_START_ROUTINE)UserInputHandler, (void*)&socketstruct, 0, 0);
		WaitForSingleObject(socketinfo->hInputThread, 2);
	}

	char incoming[MAX_SOCKET_RECV+1];
	bool done = false;
	int b_recv = 0;
	while ((!done) && (socketinfo->sock))	// The big loop.
	{
		if (!socketinfo->sock)
			break;

		memset(&incoming, 0, sizeof(incoming));
		b_recv = recv(socketinfo->sock, (char*)incoming, sizeof(incoming), 0);
		switch (b_recv)
		{
		case 0:
			LOG("[*] Remote host (%s) closed connection.", socketinfo->IP);
			done = true;
			break;
		case -1:
			LOG("[-] recv() error: %s (%u).", GetSocketError(), WSAGetLastError()); 
			done = true;
			break;
		default:
			incoming[b_recv] = '\0';
			string data(incoming);
			OnRead(&data, b_recv, socketinfo);
			break;
		}
		Sleep(100);
	}
	//
	RemoveSocketFromList(SocketListID);
	//
	return true;
}