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

#include "main.h"
#include "list.h"
#include "tux.h"

#include "interface.h"
#include "layer.h"
#include "image.h"

#include "screen_world.h"

static list_t *listLayer;

static bool_t isLayerInit = FALSE;

bool_t isLayerInicialized()
{
	return isLayerInit;
}

/*
 * Inicializuje globalny zoznam vsrtiev
 */
void initLayer()
{
	listLayer = newList();
	isLayerInit = TRUE;
}

/*
 * Add image to queue for rendering
 * *img - image to be rendered
 * x,y - coordinates where to draw the image
 * w,h - width and height of rendered part of image
 * px,py - coordinates of upper left corner of rendered part of image
 * layer - on which layer to draw
 *          (0 - under tuxanci | 1 - same as tuxanci | 2 - over tuxancami)
 */
void
addLayer(image_t * img, int x, int y, int px, int py, int w, int h, int player)
{
	layer_t *new;
	layer_t *actual;
	int i, j;

	assert(img != NULL);

	new = malloc(sizeof(layer_t));
	new->x = x;
	new->y = y;
	new->w = w;
	new->h = h;
	new->px = px;
	new->py = py;
	new->layer = player;
	new->image = img;

	//first, we check if we should insert our image at the begining of the queue
	if (listLayer->count == 0) {
		addList(listLayer, new);
		return;
	};

	if (((layer_t *)listLayer->list[0])->layer > new->layer) {
		insList(listLayer, 0, new);
		return;
	};

	//here we are sure, that we want to insert it somewhere else than the begining
	for (i = 0; i < listLayer->count; i ++) {
		actual = getList(listLayer, i);
		//if we are at the same layer, we apply insert sort in (y+h/2)
		while ((actual->layer == new->layer)) {
			if ((new->y + new->h / 2) < (actual->y + actual->h/2)) {
				insList(listLayer, i, new);
				return;
			};

			i ++;
			if (i >= listLayer->count) break;
			actual = getList(listLayer, i);

			if (actual->layer > new->layer) {
				insList(listLayer, i, new);
				return;
			};
		};
		if (i >= listLayer->count) break;

		//we check if we are on layer, that is not present yet
		if (actual->layer > new->layer) {
			insList(listLayer, i, new);
			return;
		};
	};
	addList(listLayer, new);
}

/*
 * Vykresli vsetky polozky na obrazovku
 * poukadane podla vrstvy a suradnice Y+H
 * po dokresleni sa zoznam uvolni.
 */
void drawLayer()
{
	layer_t *this;
	int i;

	for (i = 0; i < listLayer->count; i++) {
		this = (layer_t *) listLayer->list[i];

		drawImage(this->image,
				  this->x, this->y, this->px, this->py, this->w, this->h);
	}

	//printf("listLayer->count = %d\n", listLayer->count);

	destroyListItem(listLayer, free);
	listLayer = newList();
}

void drawLayerCenter(int x, int y)
{
	layer_t *this;
	int screen_x, screen_y;
	int i;
	//int count = 0;

	getCenterScreen(&screen_x, &screen_y, x, y, WINDOW_SIZE_X, WINDOW_SIZE_Y);

	for (i = 0; i < listLayer->count; i++) {
		this = (layer_t *) listLayer->list[i];

		if (this->x + this->w < screen_x || this->x > screen_x + WINDOW_SIZE_X
			|| this->y + this->h < screen_y
			|| this->y > screen_y + WINDOW_SIZE_Y) {
			continue;
		}
		//count++;

		drawImage(this->image,
				  this->x - screen_x, this->y - screen_y,
				  this->px, this->py, this->w, this->h);

		//printf("%d %d\n", this->x - screen_x, this->y - screen_y);
	}

	//printf("count = %d\n", count);

	destroyListItem(listLayer, free);
	listLayer = newList();
}

void drawLayerSplit(int local_x, int local_y, int x, int y, int w, int h)
{
	layer_t *this;
	int i;
	//int count = 0;

	for (i = 0; i < listLayer->count; i++) {
		this = (layer_t *) listLayer->list[i];

		if (this->x + this->w < x || this->x > x + w ||
			this->y + this->h < y || this->y > y + h) {
			continue;
		}
		//count++;

		if (local_x + (this->x - x) < local_x) {
			int z;

			z = local_x - (local_x + (this->x - x));

			this->x += z;
			this->px += z;
			this->w -= z;
		}

		if (local_x + (this->x - x) + this->w > local_x + w) {
			this->w -= (local_x + (this->x - x) + this->w) - (local_x + w);
		}

		if (local_y + (this->y - y) < local_y) {
			int z;

			z = local_y - (local_y + (this->y - y));

			this->y += z;
			this->py += z;
			this->h -= z;
		}

		if (local_y + (this->y - y) + this->h > local_y + h) {
			this->h -= (local_y + (this->y - y) + this->h) - (local_y + h);
		}

		drawImage(this->image,
				  local_x + (this->x - x), local_y + (this->y - y),
				  this->px, this->py, this->w, this->h);

		//printf("%d %d\n", this->x - screen_x, this->y - screen_y);
	}

	//printf("count = %d\n", count);

	destroyListItem(listLayer, free);
	listLayer = newList();
}

void flushLayer()
{
	destroyListItem(listLayer, free);
	listLayer = newList();
}

/*
 * Odstrani zoznam vrtsiev z pamete.
 */
void quitLayer()
{
	destroyListItem(listLayer, free);
	isLayerInit = FALSE;
}