//////////////////////////////////////
// Created by Pontus Fransson 2013  //
// Modified by Dennis Andersen 2014 //
//////////////////////////////////////
#ifndef INCLUDE_WINSOCK_LIB
#define INCLUDE_WINSOCK_LIB
	#pragma comment(lib, "ws2_32.lib")
#endif

#include "NetworkClient.h"

#include "Translator.h"
#include "CustomNetProtocol.h"
#include "NetworkSession.h"

#include "../NetworkDependencies/ConnectionUDP.h"
#include "../NetworkDependencies/Connection.h"
#include "../NetworkDependencies/PostBox.h"
#include "../NetworkDependencies/WinsockFunctions.h"

#include "Utilities.h"
#include "Thread/IThreadObject.h"
#include "Thread/OysterThread.h"
#include "Packing/Packing.h"

#include <queue>
#include <WinSock2.h>

#include <thread>

//For conversion from wstring to string
#include <codecvt>

using namespace Oyster::Network;
using namespace Oyster::Thread;
using namespace Utility::DynamicMemory;
using namespace Utility::Container;
using namespace std;

/*************************************
			PrivateData
*************************************/
typedef NetworkClient::ClientEventArgs CEA;

void OnRecieve_Default(NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e) {}

struct NetworkClient::PrivateData : public IThreadObject
{
	NetworkSession *owner;
	NetworkClient *parent;
	Connection connection;
	Translator translator;
	OysterThread thread;
	bool outputEvent;

	OysterByte recieveBuffer;

	//Message queue for sending and recieving
	ThreadSafeQueue<CustomNetProtocol> sendQueue;
	ThreadSafeQueue<NetEvent<NetworkClient*, NetworkClient::ClientEventArgs>> recieveQueue;

	//Testing for eventSelect.
	HANDLE socketEvents[2];
	HANDLE shutdownEvent;

	//Broadcasting
	bool broadcastingStarted;
	HANDLE broadcastEvent;
	HANDLE broadcastShutdownEvent;
	std::thread broadcastThread; 
	ConnectionUDP broadcastConnection;
	OysterByte broadcastTempMessage;
	Translator broadcastTranslator;

	//The OysterByte each message is packed in.
	OysterByte tempMessage;

	//Used to buffer messages
	OysterByte bufferedSend;
	int numPackages;

	//ID
	static unsigned int currID;
	const unsigned int ID;

	PrivateData() 
		:	ID(currID++)
		,	parent(0)
		,	owner(0)
		,	outputEvent(0)
	{
		broadcastingStarted = false;
		numPackages = 0;
		bufferedSend.Resize(MAX_NETWORK_MESSAGE_SIZE);
		tempMessage.Resize(MAX_NETWORK_MESSAGE_SIZE);
		InitWinSock();
		this->thread.Create(this, false);
		this->thread.SetPriority(Oyster::Thread::OYSTER_THREAD_PRIORITY_1);
	}
	~PrivateData()
	{ 
		SetEvent(shutdownEvent);
		this->thread.Wait();

		ShutdownWinSock();
		this->connection.Disconnect();
		this->owner = 0;
		this->parent = 0;
	}

	void ThreadEntry()
	{
		//Create alla events used in the thread
		shutdownEvent = CreateEvent(NULL, true, false, NULL);
		socketEvents[0] = WSACreateEvent();
		socketEvents[1] = WSACreateEvent();

		if(socketEvents[0] == WSA_INVALID_EVENT)
		{
			//Error
		}

		if(WSAEventSelect(this->connection.GetSocket(), socketEvents[0], FD_READ) == SOCKET_ERROR)
		{
			//Error
		}
	}

	void ThreadExit()
	{
		WSACloseEvent(socketEvents[0]);
		WSACloseEvent(socketEvents[1]);
		CloseHandle(shutdownEvent);
	}

	//Thread for receiving broadcast messages
	void BroadcastThread()
	{
		WSANETWORKEVENTS wsaEvents;

		while(WaitForSingleObject(broadcastShutdownEvent, 0) != WAIT_OBJECT_0)
		{
			int result = WSAWaitForMultipleEvents(1, &broadcastEvent, FALSE, 100, FALSE) - WSA_WAIT_EVENT_0;
			if(result == 0)
			{
				WSAEnumNetworkEvents(this->broadcastConnection.GetSocket(), broadcastEvent, &wsaEvents);
				if((wsaEvents.lNetworkEvents & FD_READ) && (wsaEvents.iErrorCode[FD_READ_BIT] == 0))
				{
					//Recieve a message
					RecvUDP();
				}
			}
		}
	}

	bool DoWork() override
	{
		WSANETWORKEVENTS wsaEvents;

		while(WaitForSingleObject(shutdownEvent, 0) != WAIT_OBJECT_0)
		{
			if(!this->connection.IsConnected())	return false;

			int result = WSAWaitForMultipleEvents(3, socketEvents, FALSE, 100, FALSE) - WSA_WAIT_EVENT_0;
			if(result == 0)
			{
				WSAEnumNetworkEvents(this->connection.GetSocket(), socketEvents[0], &wsaEvents);
				if((wsaEvents.lNetworkEvents & FD_READ) && (wsaEvents.iErrorCode[FD_READ_BIT] == 0))
				{
					//Recieve a message
					Recv();
				}
			}
			else if(result == 1)
			{
				//Send all messages in the sendQueue
				int i = this->sendQueue.Size();
				WSAResetEvent(socketEvents[1]);

				if(i == 1)
				{
					Send();
				}
				else if(i > 1)
				{
					for(int j = 0; j < i; j++)
						BufferMessage();

					SendBuffer();
				}
			}
		}

		return false;
	}

	void RecvUDP()
	{
		int errorCode = -1;

		errorCode = this->broadcastConnection.Recieve(broadcastTempMessage);
		
		if(errorCode == 0 && broadcastTempMessage.GetSize())
		{
			CustomNetProtocol protocol;
			bool ok = this->broadcastTranslator.Unpack(protocol, broadcastTempMessage);

			//Check if the protocol was unpacked correctly
			if(ok)
			{
				CEA parg;
				parg.type = CEA::EventType_ProtocolRecieved;
				parg.data.protocol = protocol;
				NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e;
				e.sender = this->parent;
				e.args.data.protocol = parg.data.protocol;
				e.args.type = parg.type;
			
				this->recieveQueue.Push(e);

				if(this->outputEvent)
				{
					printf("\t(ID: %i | IP: %s | Protocol: %i) Message recieved!\n", this->ID, this->connection.GetIpAddress().c_str(), protocol[0].value.netShort);	
				}
			}
			else
			{
				if(this->outputEvent)
				{
					printf("\t(ID: %i | IP: %s) Failed to unpack CustomNetProtocol!\n", this->ID, this->connection.GetIpAddress().c_str());	
				}
			}

			broadcastTempMessage.Clear();
		}
	}

	void SendBuffer()
	{
		if(bufferedSend.GetSize() > 0)
		{
			this->connection.Send(bufferedSend);
			//printf("2. %d, %d\n", numPackages, bufferedSend.GetSize());
			bufferedSend.Clear();

			//Debug
			numPackages = 0;
		}
	}

	void BufferMessage()
	{
		int errorCode = 0;

		if(!this->sendQueue.IsEmpty())
		{
			CustomNetProtocol p = this->sendQueue.Pop();

			this->translator.Pack(tempMessage, p);


			if(tempMessage.GetSize() > MAX_NETWORK_MESSAGE_SIZE - bufferedSend.GetSize())
			{
				//Send buffered message
				errorCode = this->connection.Send(bufferedSend);
				//printf("2. %d, %d\n", numPackages, bufferedSend.GetSize());
				bufferedSend.Clear();

				//Debug
				numPackages = 0;
			}

			bufferedSend += tempMessage;
			tempMessage.Clear();

			//Debug
			numPackages++;

			if(errorCode != 0 && errorCode != WSAEWOULDBLOCK)
			{
				if( errorCode == WSAECONNABORTED || errorCode == WSAENOTCONN)
				{
					CEA parg;
					parg.type = CEA::EventType_Disconnect;
					parg.data.protocol = p;
					NetEvent<NetworkClient*, CEA> e = { this->parent, parg };
					this->recieveQueue.Push(e);
					
					if(this->outputEvent)
					{
						printf("\t(ID: %i | IP: %s | Protocol: %i) - EventType_Disconnect && EventType_ProtocolFailedToSend \n", this->ID, this->connection.GetIpAddress().c_str(), p[0].value.netShort);	
					}
				}
				else
				{
					CEA parg;
					parg.type = CEA::EventType_ProtocolFailedToSend;
					parg.data.protocol = p;
					NetEvent<NetworkClient*, CEA> e = { this->parent, parg };
					this->recieveQueue.Push(e);

					if(this->outputEvent)
					{
						printf("\t(ID: %i | IP: %s | Protocol: %i) - EventType_ProtocolFailedToSend\n", this->ID, this->connection.GetIpAddress().c_str(), p[0].value.netShort);	
					}
				}
			}

			if(this->outputEvent)
			{
				printf("\t(ID: %i | IP: %s | Protocol: %i) Message sent!\n", this->ID, this->connection.GetIpAddress().c_str(), p[0].value.netShort);	
			}
		}
	}

	int Send()
	{
		int errorCode = 0;

		if(!this->sendQueue.IsEmpty())
		{
			//printf("\t(%i)\n", this->sendQueue.Size());
			CustomNetProtocol p = this->sendQueue.Pop();

			this->translator.Pack(tempMessage, p);
 			errorCode = this->connection.Send(tempMessage);
			tempMessage.Clear();

			if(errorCode != 0 && errorCode != WSAEWOULDBLOCK)
			{
				if( errorCode == WSAECONNABORTED || errorCode == WSAENOTCONN)
				{
					CEA parg;
					parg.type = CEA::EventType_Disconnect;
					parg.data.protocol = p;
					NetEvent<NetworkClient*, CEA> e = { this->parent, parg };
					this->recieveQueue.Push(e);
					
					if(this->outputEvent)
					{
						printf("\t(ID: %i | IP: %s | Protocol: %i) - EventType_Disconnect && EventType_ProtocolFailedToSend \n", this->ID, this->connection.GetIpAddress().c_str(), p[0].value.netShort);	
					}
				}
				else
				{
					CEA parg;
					parg.type = CEA::EventType_ProtocolFailedToSend;
					parg.data.protocol = p;
					NetEvent<NetworkClient*, CEA> e = { this->parent, parg };
					this->recieveQueue.Push(e);

					if(this->outputEvent)
					{
						printf("\t(ID: %i | IP: %s | Protocol: %i) - EventType_ProtocolFailedToSend\n", this->ID, this->connection.GetIpAddress().c_str(), p[0].value.netShort);	
					}
				}
			}

			if(this->outputEvent)
			{
				printf("\t(ID: %i | IP: %s | Protocol: %i) Message sent!\n", this->ID, this->connection.GetIpAddress().c_str(), p[0].value.netShort);	
			}
		}

		return errorCode;
	}
	int Recv()
	{
		int errorCode = -1;

		errorCode = this->connection.Recieve(tempMessage);
		
		if(errorCode == 0 && tempMessage.GetSize())
		{
			HandleRecievedData(tempMessage);
			tempMessage.Clear();


			/*	Replaced with EmptyOutbufferedQueue() and HandleRecievedData(OysterByte)
			CustomNetProtocol protocol;
			bool ok = this->translator.Unpack(protocol, temp);

			//Check if the protocol was unpacked correctly
			if(ok)
			{
				CEA parg;
				parg.type = CEA::EventType_ProtocolRecieved;
				parg.data.protocol = protocol;
				NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e = { this->parent, parg };
				this->recieveQueue.Push(e);
			}*/

		}
		//else
		//{
		//	CEA parg;
		//	parg.type = CEA::EventType_ProtocolFailedToRecieve;
		//	parg.data.nothing = 0;
		//	NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e = { this->parent, parg };
		//	this->recieveQueue.Push(e);
		//}
	
		return errorCode;
	}

	void HandleRecievedData(OysterByte& data)
	{
		//Loop through all packages that was recieved and add them to the queue.
		unsigned int size = 0;

		Oyster::Network::OysterByte msg;

		//If there is part of a message in the buffer.
		if(recieveBuffer.GetSize() > 0)
		{
			//cout << "the buffer size: " << recvBuffer.GetSize() <<endl;
			unsigned int temp = recieveBuffer.GetSize();
			size = Oyster::Packing::Unpacki(recieveBuffer);

			if(temp + data.GetSize() > size)
			{
				msg = recieveBuffer;
				recieveBuffer.Clear();
				size -= msg.GetSize();
				msg.AppendPartOfArray(data, 0, size);
				UnpackMessageAndAddToQueue(msg);
			}
			else if(temp + data.GetSize() == size)
			{
				msg = recieveBuffer;
				recieveBuffer.Clear();
				size -= msg.GetSize();
				msg += data;
				UnpackMessageAndAddToQueue(msg);
				return;
			}
			else
			{
				recieveBuffer += data;
				size = data.GetSize();
				return;
			}
		}

 		for(unsigned int i = size; i < data.GetSize(); i += size)
		{
			size = Oyster::Packing::Unpacki(&data.GetByteArray()[i]);
			if(i+size > data.GetSize())
			{
				//Add it to the recvBuffer instead.
				recieveBuffer.AppendPartOfArray(data, i, data.GetSize());
				break;
			}
			msg.Clear();
			msg.AppendPartOfArray(data, i, i+size);
			UnpackMessageAndAddToQueue(msg);
		}
	}

	void UnpackMessageAndAddToQueue(OysterByte& msg)
	{
		CustomNetProtocol protocol;
		bool ok = this->translator.Unpack(protocol, msg);

		//Check if the protocol was unpacked correctly
		if(ok)
		{
			CEA parg;
			parg.type = CEA::EventType_ProtocolRecieved;
			parg.data.protocol = protocol;
			NetEvent<NetworkClient*, NetworkClient::ClientEventArgs> e;
			e.sender = this->parent;
			e.args.data.protocol = parg.data.protocol;
			e.args.type = parg.type;
			
			this->recieveQueue.Push(e);

			if(this->outputEvent)
			{
				printf("\t(ID: %i | IP: %s | Protocol: %i) Message recieved!\n", this->ID, this->connection.GetIpAddress().c_str(), protocol[0].value.netShort);	
			}
		}
		else
		{
			if(this->outputEvent)
			{
				printf("\t(ID: %i | IP: %s) Failed to unpack CustomNetProtocol!\n", this->ID, this->connection.GetIpAddress().c_str());	
			}
		}
	}
};
unsigned int NetworkClient::PrivateData::currID = 0;

/*************************************
			NetworkClient
*************************************/

NetworkClient::NetworkClient()
	:	privateData(nullptr),
		OnRecieve(OnRecieve_Default)
{  }

NetworkClient::~NetworkClient()
{
	if(this->privateData)
	{
		delete this->privateData;
		this->privateData = NULL;
	}
}

bool NetworkClient::operator ==(const NetworkClient& obj)
{
	return (this->privateData->ID == obj.privateData->ID);
}

bool NetworkClient::operator ==(const int& ID)
{
	return this->privateData->ID == ID;
}

void NetworkClient::Update()
{
	if(!this->privateData) return;
	while (!this->privateData->recieveQueue.IsEmpty())
	{
		NetEvent<NetworkClient*, ClientEventArgs> temp = this->privateData->recieveQueue.Pop();

		this->DataRecieved(temp);
	}
}

bool NetworkClient::Connect(ConnectionInfo& socket)
{
	if(this->IsConnected()) return true;
	if(this->privateData)	return false;
	if(!this->privateData)	this->privateData = new PrivateData();

	int result = this->privateData->connection.Connect(socket, true);
	
	//Connect has succeeded
	if(result != 0)		return false;

	this->privateData->parent = this;
	this->privateData->thread.Start();

	//Connect has failed
	return true;
}

bool NetworkClient::Connect(unsigned short port, const char serverIP[])
{
	//Return true if you are already connected.
	if(this->IsConnected())
		return true;

	if(!this->privateData)
		this->privateData = new PrivateData();

	int result = this->privateData->connection.Connect(port, serverIP, true);
	
	//Connect has succeeded
	if(result != 0)		return false;
	this->privateData->owner = 0;
	this->privateData->parent = this;
	this->privateData->thread.Start();

	//Connect has failed
	return true;
}

bool NetworkClient::Connect(unsigned short port, std::wstring serverIP)
{
	//Convert from wstring to string.
	typedef std::codecvt_utf8<wchar_t> convert_typeX;
    std::wstring_convert<convert_typeX, wchar_t> converterX;

	std::string ip = converterX.to_bytes(serverIP);

	return this->Connect(port, ip.c_str());
}

bool NetworkClient::Reconnect()
{
	//Return true if you are already connected.
	if(this->IsConnected())	
		return true;

	if(!this->privateData)	this->privateData = new PrivateData();

	int result = this->privateData->connection.Reconnect();

	if(result != 0)
	{
		return false;
	}
	this->privateData->owner = 0;
	this->privateData->parent = this;
	this->privateData->thread.Start();

	return true;
}

void NetworkClient::Disconnect()
{
	if(!privateData) return;

	SetEvent(privateData->shutdownEvent);
	privateData->thread.Wait();

	privateData->connection.Disconnect();
	this->privateData->sendQueue.Clear();
	this->privateData->recieveQueue.Clear();
}

void NetworkClient::Send(CustomProtocolObject& protocol)
{
	this->privateData->sendQueue.Push(protocol.GetProtocol());
	WSASetEvent(this->privateData->socketEvents[1]);
}

void NetworkClient::Send(CustomNetProtocol& protocol)
{
	this->privateData->sendQueue.Push(protocol);
	WSASetEvent(this->privateData->socketEvents[1]);
}

void NetworkClient::SetOwner(NetworkSession* owner)
{
	this->privateData->owner = owner;
}

void NetworkClient::SetMessagePump( NetworkClient::ClientEventFunction func )
{
	if( func )
	{
		this->OnRecieve = func;
	}
	else
	{
		this->OnRecieve = OnRecieve_Default;
	}
}

bool NetworkClient::IsConnected()
{
	if(!this->privateData) return false;
	return privateData->connection.IsConnected();
}

int NetworkClient::GetID() const
{
	return this->privateData->ID;
}

void NetworkClient::DataRecieved(NetEvent<NetworkClient*, ClientEventArgs> e)
{
	if(this->privateData->owner)
	{
		this->privateData->owner->ClientEventCallback(e);
	}
	else
	{
		this->OnRecieve( e );
	}
}

std::string NetworkClient::GetIpAddress()
{
	return this->privateData->connection.GetIpAddress();
}
void NetworkClient::OutputEventData(bool output)
{
	this->privateData->outputEvent;
}

bool NetworkClient::StartListeningForBroadcasting(unsigned short port)
{
	//Create privateData if it doesn't exists.
	if(this->privateData == NULL)
	{
		privateData = new PrivateData;
	}

	//Initiate broadcasting only if it's not started.
	if(!this->privateData->broadcastingStarted)
	{
		//Create UDP connection
		int result = this->privateData->broadcastConnection.InitiateBroadcastClient(port);
		if(result)
		{
			return false;
		}

		//Create event for closing the thread.
		this->privateData->broadcastShutdownEvent = CreateEvent(NULL, true, false, NULL);
		if(this->privateData->broadcastShutdownEvent == NULL)
		{
			this->privateData->broadcastConnection.Disconnect();
			return false;
		}

		//Creating event for broadcast messages on the UDP connection.
		this->privateData->broadcastEvent = WSACreateEvent();
		if(this->privateData->broadcastEvent == WSA_INVALID_EVENT)
		{
			this->privateData->broadcastConnection.Disconnect();
			CloseHandle(this->privateData->broadcastShutdownEvent);
			return false;
		}

		//Set the event for only Receiving.
		if(WSAEventSelect(this->privateData->broadcastConnection.GetSocket(), this->privateData->broadcastEvent, FD_READ) == SOCKET_ERROR)
		{
			this->privateData->broadcastConnection.Disconnect();
			CloseHandle(this->privateData->broadcastShutdownEvent);
			WSACloseEvent(this->privateData->broadcastEvent);
			return false;
		}

		//Start thread receiving broadcast messages.
		this->privateData->broadcastThread = thread(&PrivateData::BroadcastThread, this->privateData);
		if(!this->privateData->broadcastThread.joinable())
		{
			this->privateData->broadcastConnection.Disconnect();
			CloseHandle(this->privateData->broadcastShutdownEvent);
			WSACloseEvent(this->privateData->broadcastEvent);
			return false;
		}

		this->privateData->broadcastingStarted = true;
	}

	return true;
}

void NetworkClient::StopListeningForBroadcasting()
{
	if(this->privateData)
	{
		if(this->privateData->broadcastingStarted)
		{
			//Tell the thread to shutdown
			WSASetEvent(this->privateData->broadcastShutdownEvent);

			//Wait for thread
			this->privateData->broadcastThread.join();

			WSACloseEvent(this->privateData->broadcastEvent);
			CloseHandle(this->privateData->broadcastShutdownEvent);

			this->privateData->broadcastConnection.Disconnect();

			this->privateData->broadcastingStarted = false;
		}
	}
}