#include "GuiUpdater.h"


GuiUpdater::GuiUpdater(int port, hostent *serv)
{
	portno = port;
	server = serv;
}


GuiUpdater::~GuiUpdater()
{

}


void GuiUpdater::init()
{
	char buffer[256];
	int n;

    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    if (sockfd < 0) {
        printf("Error opening socket\n");
		exit(0);
	}

    if (server == NULL) {
        printf("Error, no such host\n");
        exit(0);
    }

    memset((char *) &serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    memcpy((char *)&serv_addr.sin_addr.s_addr,
    	   (char *)server->h_addr,
           server->h_length);
    serv_addr.sin_port = htons(portno);

    if (connect(sockfd,(struct sockaddr*) &serv_addr,sizeof(serv_addr)) < 0) {
        printf("Error connecting!\n");
		exit(0);
	}

    // astept mesaj de la server
    memset(buffer, 0, 256);
    n = recv(sockfd, buffer, 255, 0);

    if (n < 0) {
	    printf("Error reading from socket!\n");
		exit(0);
	}

    printf("[SRV]%s\n", buffer);

}

void GuiUpdater::receiveData(int sock, void* buffer, size_t size)
{
	size_t total;
	int ret;

	for (total = 0; total < size; total += ret) {
		ret = recv(sock, (char *) buffer + total, size - total, 0);
		if (ret <= 0) {
			perror("recv");
			exit(-1);
		}
	}
}

void* GuiUpdater::unpackInt(void *buffer, int &a)
{
	int *buff = (int *) buffer;
	a = *buff ++;

	return buff;
}

void* GuiUpdater::unpackScalar(void *buffer, btScalar &a)
{
	float *buff = (float *) buffer;
	a = *buff ++;

	return buff;
}

void* GuiUpdater::unpackVector3(void *buffer, btVector3 &v)
{
	btScalar a;

	buffer = unpackScalar(buffer, a);
	v.setX(a);
	buffer = unpackScalar(buffer, a);
	v.setY(a);
	buffer = unpackScalar(buffer, a);
	v.setZ(a);

	return buffer;
}

void* GuiUpdater::unpackMatrix3x3(void *buffer, btMatrix3x3 &m)
{
	btVector3 v;

	for (int i = 0; i < 3; ++ i) {
		buffer = unpackVector3(buffer, m[i]);
	}

	return buffer;
}

void GuiUpdater::unpackAddData(void *buffer, int n, map<int,guiAddData *> &addObjects)
{
	for (int i = 0; i < n; ++ i) {
		guiAddData *obj = new guiAddData;
		int j;

		buffer = unpackInt(buffer, obj->id);
		buffer = unpackInt(buffer, obj->numIndices);

		obj->indexPointer = new int [obj->numIndices];
		for (j = 0; j < obj->numIndices; ++ j) {
			buffer = unpackInt(buffer, obj->indexPointer[j]);
		}

		buffer = unpackInt(buffer, obj->numVertices);
		obj->vertexPointer = new btVector3 [obj->numVertices];
		for (j = 0; j < obj->numVertices; ++ j) {
				buffer = unpackVector3(buffer, obj->vertexPointer[j]);
		}

		addObjects[obj->id] = obj;
	}
}

void GuiUpdater::unpackUpdateData(void *buffer, int n, map<int, guiUpdateData *> &updateObjects)
{
	for (int i = 0; i < n; ++ i) {
		guiUpdateData *obj = new guiUpdateData;
		int j;

		buffer = unpackInt(buffer, obj->id);

		for (j = 0; j < 16; ++ j) {
			buffer = unpackScalar(buffer, obj->m[j]);
		}

		buffer = unpackMatrix3x3(buffer, obj->rot);

		buffer = unpackVector3(buffer, obj->aabbMin);

		buffer = unpackVector3(buffer, obj->aabbMax);

		updateObjects[obj->id] = obj;
	}
}

void GuiUpdater::applyChanges(map<int, guiAddData *> addObjects, map<int, guiUpdateData *> updateObjects, int *removeObjects, int remObjNum)
{
//	getchar();
	map<int, guiAddData *>::iterator it_add = addObjects.begin();
	for ( ; it_add != addObjects.end(); it_add ++) {
//		printf("[%d]\n", addObjects.coun);
		if (m_cache.find(it_add->first) != m_cache.end()) {
			printf("Adding existing object\n");
			exit(-1);
		}

		guiObject *obj = new guiObject;
		obj->ad = it_add->second;
		if (m_cache[it_add->second->id]) delete m_cache[it_add->second->id];
		m_cache[it_add->second->id] = obj;
	}

	map<int, guiUpdateData *>::iterator it_update = updateObjects.begin();
	for ( ; it_update != updateObjects.end(); it_update ++) {
		if (m_cache.find(it_update->first) != m_cache.end()) {
			guiObject *obj = m_cache.find(it_update->first)->second;
			obj->ud = it_update->second;
		} else {
			printf("Updating missing object\n");
//			exit(-1);
		}
	}

	map<int, guiObject *>::iterator it;
	for (int i = 0; i < remObjNum; ++ i) {
		it = m_cache.find(removeObjects[i]);
		if (it != m_cache.end()) {
			delete it->second;
			m_cache.erase(it);
		}
	}
}

int GuiUpdater::update()
{
	map<int, guiAddData *> addObjects;
	map<int, guiUpdateData *> updateObjects;
	int *removeObjects;

//	char buffer[256];
	char ask = 'a';
	int n;

	n = send(sockfd,(const void*) &ask,1, 0);
	if (n < 0) {
			printf("Error writing to socket!\n");
		exit(0);
	}


	int size;

	// receive add objects
	receiveData(sockfd, (void *) &n, sizeof(int));
	receiveData(sockfd, (void *) &size, sizeof(int));


	void *buffer = new char [size];
	receiveData(sockfd, (void *) buffer, size);
	unpackAddData(buffer, n, addObjects);
	delete [] (char *) buffer;
	printf("added object no = %d (%d)\n", (int) addObjects.size(), n);

	// receive update objects
	receiveData(sockfd, (void *) &n, sizeof(int));
	receiveData(sockfd, (void *) &size, sizeof(int));
	buffer = new char [size];
	receiveData(sockfd, (void *) buffer, size);
	unpackUpdateData(buffer, n, updateObjects);
	delete [] (char *) buffer;

	printf("updated object no = %d (%d)\n", (int) updateObjects.size(), n);
	map<int, guiUpdateData *>::iterator it = updateObjects.begin();
	for ( ; it != updateObjects.end(); it ++) {
		for (int j = 0; j < 16; ++ j) {
		//	buffer = unpackScalar(buffer, obj->m[j]);
			printf("TEST %d, %d: %f\n", j, it->first, it->second->m[j]);
		}
	}

	// receive remove objects
	receiveData(sockfd, (void *) &n, sizeof(int));
	removeObjects = new int[n];	// the number of objects (object ids in this case)
	receiveData(sockfd, (void *) &size, sizeof(int));
	buffer = new char [size];
	receiveData(sockfd, (void *) buffer, size);

	for (int i = 0; i < n; ++ i) {
		buffer = unpackInt(buffer, removeObjects[i]);
	}

	delete [] (int *) buffer;

	applyChanges(addObjects, updateObjects, removeObjects, n);

//	gd = new guiUpdateData[n];
//	receiveData(sockfd, (void *) gd, sizeof(guiUpdateData) * n);

	return n;
}