//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//serveur
#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>

#include <unistd.h>
#include <stdio.h>
#include <string.h>

#include <stdlib.h>

#include <SDL/SDL.h>



#include "CTile.h"
#include <sstream>
#include <iostream>

using namespace std;
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
void envoyer(char *msg);
void recevoir();
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
struct sockaddr_in InfoSocketServeur, InfoSocketClient;

socklen_t SocketServeur, SocketClient;
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////

SDL_Surface *image, *image2;
SDL_Rect rect, RectPostion, rect2, RectPostion2;

//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
int PositionX=320, PositionY=320, PositionXX=320, PositionYY=320;
int PositionX2=320, PositionY2=320, PositionXX2=320, PositionYY2=320;//joueur2

int CameraX=320, CameraY=320;

int TempReel=0;

int nextUpdateTime = 0;

//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
void AfficherTest(SDL_Surface *Cible, int x, int y);//affiche le joueur
void AfficherAutre(SDL_Surface *Cible, int x, int y);//affiche l'autre
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
bool trucX()
{
	if ((PositionX<320-1) && (PositionX < 1024-320-1)){
	return false;
	}
	else if ((PositionX>320-1) && (PositionX > 1024-320-1)){
	return false;
	}
	else{
	return true;
	}
}
bool trucY()
{
	if ((PositionY< 240-1) && (PositionY < 1024-240-1)){
	return false;
	}
	if ((PositionY> 240-1) && (PositionY > 1024-240-1)){
	return false;
	}
	else{
	return true;
	}
}

//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////

int main(int argc, char** argv)

{
	SocketServeur = socket(AF_INET, SOCK_STREAM, 0);

	if (SocketServeur < 0)
	{
	cout<<"le socket n'a pu etre crée"<<endl;
	return 0;
	}

	InfoSocketServeur.sin_family = AF_INET;

	InfoSocketServeur.sin_port = htons(3400); 

	InfoSocketServeur.sin_addr.s_addr = INADDR_ANY; 
	memset(&(InfoSocketServeur.sin_zero), 0, 8);

	//associs le port ect.. a la socket
	if((bind(SocketServeur, (struct sockaddr *)&InfoSocketServeur, sizeof(struct sockaddr))) < 0)  

	{

	cout<<"la socket a merdee"<<endl;
	return 0;

	}

	if(listen(SocketServeur, 3400) < 0)

	{

	cout<<"ecoute imposible"<<endl;
	return 0;

	}

	cout<<"en attente de connection"<<endl;

	socklen_t SizeInfo = sizeof(struct sockaddr_in);
	SocketClient = accept(SocketServeur, (struct sockaddr *)&InfoSocketClient, &SizeInfo);

		



	if (SocketClient <= 0)
	{

	cout<<"Impossible d'accepter la socket distante"<<endl;

	}

	else

	{
	cout<<"c'est partis !!!"<<endl;

	Uint8 *keyarray = SDL_GetKeyState(NULL);

	
	image = SDL_LoadBMP("sprite.bmp");
	image2 = SDL_LoadBMP("sprite2.bmp");

	bool etat =true;


	SDL_Surface *pscreen ;

	SDL_Event Evenement;

	

	if(SDL_Init(SDL_INIT_VIDEO|SDL_INIT_JOYSTICK) < 0){exit(1);}



	atexit(SDL_Quit);

	

	pscreen = SDL_SetVideoMode(640, 480, 32, SDL_HWSURFACE | SDL_DOUBLEBUF);

	if(pscreen == NULL){ exit(1);}



	SDL_WM_SetCaption ("SERVEUR", NULL);





	CTitle *test_titles;

	test_titles = new CTitle();



	test_titles->ChargerTiles();

	test_titles->map.largeur = 1024/16;

	test_titles->map.hauteur = 1024/16;

	test_titles->map.PointX  = 640 /16;

	test_titles->map.PointY  = 480 /16;



	while(etat)

	{

		TempReel=SDL_GetTicks();


		if(SDL_PollEvent(&Evenement))

		{

			switch (Evenement.type)

			{

			case(SDL_QUIT):etat = false; break;

				

			case SDL_KEYDOWN:

			switch(Evenement.key.keysym.sym)

			{



			case SDLK_KP_ENTER:  cout<<"camera: "<<CameraY<<"  position: "<<PositionY<<endl;  break;

			}
			break;

		}

						

			

	}
			/*if (TempReel>nextUpdateTime)

			{nextUpdateTime = SDL_GetTicks() + 10;*/

	if (keyarray[SDLK_LEFT])	{ if(trucX()){ CameraX -= 2; } PositionX -= 2; }
	if (keyarray[SDLK_RIGHT])	{ if(trucX()){ CameraX += 2; } PositionX += 2; }
	if (keyarray[SDLK_UP])		{ if(trucY()){ CameraY -= 2; } PositionY -= 2; }
	if (keyarray[SDLK_DOWN]) 	{ if(trucY()){ CameraY += 2; } PositionY += 2; }

	if (CameraX < 320-1) 		{ CameraX = 320; }
	else if (CameraX > 1024-320-1)	{ CameraX = 1024-320; }

	if (CameraY < 240-1)		{ CameraY = 240; }
	else if (CameraY > 1024-240-1)	{ CameraY = 1024-240; }


	if ((PositionX < 1024-320-1) && (PositionX > 320))	{ PositionXX = 320; }
	else if (PositionX < 320)				{ PositionXX = PositionX; }
	else if (PositionX > 1024-320-1)			{ PositionXX = 320 + (320-(1024-PositionX)); }

	if ((PositionY > 240-1) && (PositionY < 1024-240-1))	{ PositionYY = 240; }
	else if (PositionY < 240)				{ PositionYY = PositionY; }
	else if (PositionY > 1024-240-1)			{ PositionYY = 240 + (240-(1024-PositionY)); }
//}
	if (TempReel>nextUpdateTime)

	{
	nextUpdateTime = SDL_GetTicks() + 150;

	ostringstream oss (ostringstream::out);
	oss <<  PositionX;
	envoyer((char*)oss.str().c_str());

	ostringstream ossy (ostringstream::out);
	ossy <<  PositionY;
	envoyer((char*)ossy.str().c_str());

	recevoir();
	}
	//////////////////////////////////////////////////////////////////


	test_titles->AfficherTiles(pscreen, CameraX, CameraY);

	AfficherTest(pscreen, PositionXX, PositionYY);

	AfficherAutre(pscreen, PositionX2 - (CameraX-320), PositionY2 - (CameraY-240));

	SDL_Flip(pscreen);

	SDL_FillRect(pscreen,NULL,0);


	}



	test_titles->LibererTiles();

}

	shutdown(SocketClient, 2);
	return 0;



}

//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////

void AfficherTest(SDL_Surface *Cible, int x, int y)
{
	rect.h=16;

	rect.w=16;



	RectPostion.x=x;

	RectPostion.y=y;

	SDL_BlitSurface(image, &rect, Cible, &RectPostion);
}
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
void envoyer(char *msg)
{
	unsigned long nb;

	nb = strlen(msg) + 1;
	send( SocketClient, &nb, sizeof( unsigned long ), 0 );
	send( SocketClient, msg, nb, 0 );
}
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
void recevoir()

{

	char buffer[256]; unsigned long nb;

	recv( SocketClient, &nb, sizeof( unsigned long ), 0 );
	recv( SocketClient, buffer, nb, 0 );

	char buffer2[256]; unsigned long nb2;

	recv( SocketClient, &nb2, sizeof( unsigned long ), 0 );
	recv( SocketClient, buffer2, nb2, 0 );

	int trucX =atoi(buffer);
	PositionX2=trucX;

	int trucY =atoi(buffer2);
	PositionY2=trucY;

	//cout<<"Message recu: "<<PositionX2<<"    "<<PositionY2<<endl;

}
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////
void AfficherAutre(SDL_Surface *Cible, int x, int y)
{
	rect2.h=16;

	rect2.w=16;



	RectPostion2.x=x;

	RectPostion2.y=y;

	SDL_BlitSurface(image2, &rect2, Cible, &RectPostion2);
}
//////////////////////////////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////