/* server.cpp */
#include <stdio.h>
#include <enet/enet.h>
#include "../../CommonInterfaces/CommonGUIHelperInterface.h"
#include "Bullet3Common/b3CommandLineArgs.h"

#ifdef NO_SHARED_MEMORY
	#include "PhysicsServerCommandProcessor.h"
	typedef PhysicsServerCommandProcessor MyCommandProcessor;
#else
	#include "SharedMemoryCommandProcessor.h"
	typedef SharedMemoryCommandProcessor MyCommandProcessor;
#endif //NO_SHARED_MEMORY

#include "SharedMemoryCommands.h"
#include "Bullet3Common/b3AlignedObjectArray.h"
#include "PhysicsServerCommandProcessor.h"
#include "../Utils/b3Clock.h"
	
bool gVerboseNetworkMessagesServer = false;

void MySerializeInt(unsigned int sz, unsigned char* output)
{
	unsigned int tmp = sz;
	output[0] = tmp & 255;
	tmp = tmp >> 8;
	output[1] = tmp & 255;
	tmp = tmp >> 8;
	output[2] = tmp & 255;
	tmp = tmp >> 8;
	output[3] = tmp & 255;
}



int main(int argc, char *argv[])
{
	b3CommandLineArgs parseArgs(argc,argv);
	b3Clock clock;
	double timeOutInSeconds = 10;

	DummyGUIHelper guiHelper;
	MyCommandProcessor* sm = new MyCommandProcessor;
	sm->setGuiHelper(&guiHelper);

	int port = 1234;
	if (parseArgs.GetCmdLineArgument("port",port))
	{
		printf("Using UDP port %d\n", port);
	}

	gVerboseNetworkMessagesServer = parseArgs.CheckCmdLineFlag("verbose");

#ifndef NO_SHARED_MEMORY
	int key = 0;
	if (parseArgs.GetCmdLineArgument("sharedMemoryKey",key))
	{
		sm->setSharedMemoryKey(key);
	}
#endif//NO_SHARED_MEMORY

//	PhysicsDirect* sm = new PhysicsDirect(sdk);

	//PhysicsClientSharedMemory* sm = new PhysicsClientSharedMemory();

	bool isPhysicsClientConnected = sm->connect();

	if (isPhysicsClientConnected)
	{
		
		ENetAddress address;
		ENetHost *server;
		ENetEvent event;
		int serviceResult;

		puts("Starting server");

		if (enet_initialize() != 0)
		{
			puts("Error initialising enet");
			exit(EXIT_FAILURE);
		}


		/* Bind the server to the default localhost.     */
		/* A specific host address can be specified by   */
		/* enet_address_set_host (& address, "x.x.x.x"); */
		address.host = ENET_HOST_ANY;
		/* Bind the server to port 1234. */
		address.port = port;

		server = enet_host_create(&address,
			32,   /* number of clients */
			2,    /* number of channels */
			0,    /* Any incoming bandwith */
			0);   /* Any outgoing bandwith */

		if (server == NULL)
		{
			puts("Could not create server host");
			exit(EXIT_FAILURE);
		}


		while (true)
		{
			b3Clock::usleep(0);

			serviceResult = 1;

			/* Keep doing host_service until no events are left */
			while (serviceResult > 0)
			{
				/* Wait up to 1000 milliseconds for an event. */
				serviceResult = enet_host_service(server, &event, 0);
				if (serviceResult > 0)
				{

					switch (event.type)
					{
                        case ENET_EVENT_TYPE_CONNECT:
                        {
						printf("A new client connected from %x:%u.\n",
							event.peer->address.host,
							event.peer->address.port);

						/* Store any relevant client information here. */
						event.peer->data = (void*)"Client information";

						break;
                        }
					case ENET_EVENT_TYPE_RECEIVE:
                        {
						if (gVerboseNetworkMessagesServer)
						{
							printf("A packet of length %u containing '%s' was "
								"received from %s on channel %u.\n",
								event.packet->dataLength,
								event.packet->data,
								event.peer->data,
								event.channelID);
						}
						SharedMemoryCommand cmd;

						SharedMemoryCommand* cmdPtr = 0;

						//performance test
						if (event.packet->dataLength == sizeof(int))
						{
							cmdPtr = &cmd;
							cmd.m_type = *(int*)event.packet->data;
						}

						if (event.packet->dataLength == sizeof(SharedMemoryCommand))
						{
							cmdPtr = (SharedMemoryCommand*)event.packet->data;
						}
						if (cmdPtr)
						{
							SharedMemoryStatus serverStatus;
							b3AlignedObjectArray<char> buffer;
							buffer.resize(SHARED_MEMORY_MAX_STREAM_CHUNK_SIZE);

							bool hasStatus = sm->processCommand(*cmdPtr,serverStatus, &buffer[0], buffer.size());

							double startTimeSeconds = clock.getTimeInSeconds();
							double curTimeSeconds  = clock.getTimeInSeconds();

							while ((!hasStatus) && ((curTimeSeconds - startTimeSeconds) <timeOutInSeconds))
							{
								hasStatus = sm->receiveStatus(serverStatus, &buffer[0], buffer.size());
								curTimeSeconds = clock.getTimeInSeconds();
							}
							if (gVerboseNetworkMessagesServer)
							{
								printf("buffer.size = %d\n", buffer.size());
								printf("serverStatus.m_numDataStreamBytes = %d\n", serverStatus.m_numDataStreamBytes);
							}
							if (hasStatus)
							{
								b3AlignedObjectArray<unsigned char> packetData;
								unsigned char* statBytes = (unsigned char*)&serverStatus;

								if (cmdPtr->m_type == CMD_STEP_FORWARD_SIMULATION)
								{
									packetData.resize(4 + sizeof(int));
									int sz = packetData.size();
									int curPos = 0;

									MySerializeInt(sz, &packetData[curPos]);
									curPos += 4;
									for (int i = 0; i < sizeof(int); i++)
									{
										packetData[i + curPos] = statBytes[i];
									}
									curPos += sizeof(int);
									ENetPacket *packet = enet_packet_create(&packetData[0], packetData.size(), ENET_PACKET_FLAG_RELIABLE);
									enet_peer_send(event.peer, 0, packet);
								}
								else
								{
									//create packetData with [int packetSizeInBytes, status, streamBytes)
									packetData.resize(4 + sizeof(SharedMemoryStatus) + serverStatus.m_numDataStreamBytes);
									int sz = packetData.size();
									int curPos = 0;

									MySerializeInt(sz, &packetData[curPos]);
									curPos += 4;
									for (int i = 0; i < sizeof(SharedMemoryStatus); i++)
									{
										packetData[i + curPos] = statBytes[i];
									}
									curPos += sizeof(SharedMemoryStatus);

									for (int i = 0; i < serverStatus.m_numDataStreamBytes; i++)
									{
										packetData[i + curPos] = buffer[i];
									}

									ENetPacket *packet = enet_packet_create(&packetData[0], packetData.size(), ENET_PACKET_FLAG_RELIABLE);
									enet_peer_send(event.peer, 0, packet);
									//enet_host_broadcast(server, 0, packet);
								}
							}
						}
						else
						{
							printf("received packet with unknown contents\n");
						}


						/* Tell all clients about this message */
						//enet_host_broadcast(server, 0, event.packet);

						break;
                        }
					case ENET_EVENT_TYPE_DISCONNECT:
                        {
						printf("%s disconnected.\n", event.peer->data);

						/* Reset the peer's client information. */

						event.peer->data = NULL;

						break;
                        }
                    default:
                        {
                        
                        }
					}
				}
				else if (serviceResult > 0)
				{
					puts("Error with servicing the server");
					exit(EXIT_FAILURE);
				}
			}

		}

		enet_host_destroy(server);
		enet_deinitialize();
	}
	delete sm;

	return 0;

}
