#include <stdlib.h>
#include <string.h>
#include <assert.h>

#include "main.h"
#include "shot.h"
#include "gun.h"
#include "net_multiplayer.h"
#include "proto.h"
#include "idManager.h"

#ifndef PUBLIC_SERVER
#include "image.h"
#include "layer.h"
#include "screen_world.h"
#endif

#ifdef PUBLIC_SERVER
#include "publicServer.h"
#endif

#ifndef PUBLIC_SERVER

static image_t *g_shot_simple;
static image_t *g_shot_lasserX;
static image_t *g_shot_lasserY;
static image_t *g_shot_bombball;

#endif

static bool_t isShotInit = FALSE;

bool_t isShotInicialized()
{
	return isShotInit;
}

void initShot()
{
#ifndef PUBLIC_SERVER
	assert( isImageInicialized() == TRUE );
#endif

#ifndef PUBLIC_SERVER

	g_shot_simple = addImageData("shot.png", IMAGE_ALPHA, "shot", IMAGE_GROUP_BASE);
	g_shot_lasserX = addImageData("lasserX.png", IMAGE_NO_ALPHA, "lasserX", IMAGE_GROUP_BASE);
	g_shot_lasserY = addImageData("lasserY.png", IMAGE_NO_ALPHA, "lasserY", IMAGE_GROUP_BASE);
	g_shot_bombball = addImageData("bombball.png", IMAGE_ALPHA, "bombball", IMAGE_GROUP_BASE);

#endif

	isShotInit = TRUE;
}

shot_t* newShot(int x,int y, int px, int py, int gun, int author_id)
{
	shot_t *new;
	tux_t *author;

	new = malloc( sizeof(shot_t) );
	memset(new, 0, sizeof(shot_t) );

	new->id = getNewID();
	new->x = x;
	new->y = y;
	new->px = px;
	new->py = py;
	new->gun = gun;
	new->author_id = author_id;

	new->position = POSITION_UNKNOWN;

	author = getObjectFromSpaceWithID(getCurrentArena()->spaceTux, author_id);

	if( author != NULL )
	{
		new->position = author->position;
	}

	new->isCanKillAuthor = FALSE;

	switch( gun )
	{
		case GUN_SIMPLE :
			new->w = GUN_SHOT_WIDTH; 
			new->h = GUN_SHOT_HEIGHT; 
#ifndef PUBLIC_SERVER	
			new->img = g_shot_simple;
#endif
		break;

		case GUN_LASSER :
			switch( author-> position )
			{
				case TUX_RIGHT :
				case TUX_LEFT :
					new->w = GUN_LASSER_HORIZONTAL; 
					new->h = GUN_SHOT_VERTICAL; 
#ifndef PUBLIC_SERVER	
					new->img = g_shot_lasserX;
#endif
				break;
				case TUX_UP :
				case TUX_DOWN :
					new->w = GUN_SHOT_VERTICAL; 
					new->h = GUN_LASSER_HORIZONTAL; 
#ifndef PUBLIC_SERVER	
					new->img = g_shot_lasserY;
#endif
				break;
			}
		break;

		case GUN_BOMBBALL :
			new->w = GUN_BOMBBALL_WIDTH; 
			new->h = GUN_BOMBBALL_HEIGHT; 

#ifndef PUBLIC_SERVER	
			new->img = g_shot_bombball;
#endif
		break;

		default :
			assert( ! "Premenna weapon ma zlu hodnotu !" );
		break;
	}

	return new;
}

void replaceShotID(shot_t *shot, int id)
{
	replaceID(shot->id, id);
	shot->id = id;
}


void getStatusShot(void *p, int *id, int *x,int *y, int *w, int *h)
{
	shot_t *shot;

	shot = p;
	*id = shot->id;
	*x = shot->x;
	*y = shot->y;
	*w = shot->w;
	*h = shot->h;
}

void setStatusShot(void *p, int x, int y, int w, int h)
{
	shot_t *shot;

	shot = p;
	shot->x = x;
	shot->y = y;
	shot->w = w;
	shot->h = h;
}

#ifndef PUBLIC_SERVER	

void drawShot(shot_t *p)
{
	assert( p != NULL );
	addLayer(p->img, p->x, p->y, 0, 0, p->img->w, p->img->h, TUX_LAYER);
}

void drawListShot(list_t *listShot)
{
	shot_t *thisShot;
	int i;

	assert( listShot != NULL );

	for( i = 0 ; i < listShot->count ; i++ )
	{
		thisShot  = (shot_t *)listShot->list[i];
		assert( thisShot != NULL );
		drawShot(thisShot);
	}
}

#endif

static int getRandomCourse(int x, int y)
{
	int ret = -1; // no warnning

	do{
		switch( random() % 3 )
		{
			case 0 :
				ret = y;
			break;
			case 1 :
				ret = -y;
			break;
			case 2 :
				ret = 0;
			break;
		}
	}while( ret == x );

	return ret;
}

void boundBombBall(shot_t *shot)
{
	if( shot->gun != GUN_BOMBBALL )
	{
		return;
	}

	shot->px  = getRandomCourse(shot->px, +10);
	shot->py  = getRandomCourse(shot->py, +10);
	shot->isCanKillAuthor = 1;

	if( getNetTypeGame() == NET_GAME_TYPE_SERVER )
	{
		proto_send_shot_server(PROTO_SEND_ALL, NULL, shot);
	}
}

void transformOnlyLasser(shot_t *shot)
{
	space_t *space;
	int mustRefesh = 0;

	space  = getCurrentArena()->spaceShot;

	if( getObjectFromSpaceWithID(space, shot->id) != NULL )
	{
		mustRefesh = 1;
	}

	if( mustRefesh )
	{
		delObjectFromSpace(space, shot);
	}

	switch( shot->position )
	{
		case TUX_RIGHT :
		case TUX_LEFT :
			shot->w = GUN_LASSER_HORIZONTAL; 
			shot->h = GUN_SHOT_VERTICAL; 
#ifndef PUBLIC_SERVER	
			shot->img = g_shot_lasserX;
#endif
		break;
		case TUX_UP :
		case TUX_DOWN :
			shot->w = GUN_SHOT_VERTICAL; 
			shot->h = GUN_LASSER_HORIZONTAL; 
#ifndef PUBLIC_SERVER	
			shot->img = g_shot_lasserY;
#endif
		break;
	}

	if( mustRefesh) 
	{
		addObjectToSpace(space, shot);
	}
}

static void action_moveShot(space_t *space, shot_t *shot, void *p)
{
	int new_x, new_y;
	arena_t *arena;

	arena = getCurrentArena();

	new_x = shot->x + shot->px;
	new_y = shot->y + shot->py;

	moveObjectInSpace(space, shot, new_x, new_y);

	if( shot->x+shot->w < 0 || shot->x > arena->w ||
	    shot->y+shot->h < 0 || shot->y > arena->h )
	{
		delObjectFromSpaceWithObject(space, shot, destroyShot);
	}
}

void eventMoveListShot(arena_t *arena)
{
	actionSpace(arena->spaceShot, action_moveShot, NULL);
}

static int isValueInList(list_t *list, int x)
{
	int i;

	for( i = 0 ; i < list->count ; i++ )
	{
		if( x == ( *(int *)list->list[i] ) )
		{
			return 1;
		}
	}

	return 0;
}

static void action_check(space_t *space, shot_t *shot, client_t *client)
{
	if( isValueInList(client->listSeesShot, shot->id) == 0 )
	{
		addList(client->listSeesShot, newInt(shot->id) );
		proto_send_shot_server(PROTO_SEND_ONE, client, shot);
	}
}

void checkShotIsInTuxScreen(arena_t *arena)
{
	int screen_x, screen_y;
	tux_t *thisTux;
	client_t *thisClient;
	list_t *listClient;
	int i;

	if( getNetTypeGame() != NET_GAME_TYPE_SERVER )
	{
		return;
	}

	listClient = getListServerClient();

	for( i = 0 ; i < listClient->count ; i++ )
	{
		thisClient = (client_t *)listClient->list[i];
		thisTux = (tux_t *)thisClient->tux;

		if( thisTux == NULL || thisTux->control != TUX_CONTROL_NET )
		{
			continue;
		}

		getCenterScreen(&screen_x, &screen_y, thisTux->x, thisTux->y);

		actionSpaceFromLocation(arena->spaceShot, action_check,
			thisClient, screen_x, screen_y,  WINDOW_SIZE_X, WINDOW_SIZE_Y);

		while( thisClient->listSeesShot->count > 100 )
		{
			delListItem(thisClient->listSeesShot, 0, free);
		}
	}
}

void destroyShot(shot_t *p)
{
	assert( p != NULL );
	
	delID(p->id);

	free(p);
}

void quitShot()
{
	isShotInit = FALSE;
}