#include "fade.h"
#include "const.h"
#include <iostream>

// Constructor
Fade::Fade(SDL_Renderer *renderer, param_t *param)
{
	// Copia punteros y objetos
	this->renderer = renderer;
	this->param = param;

	// Crea la textura donde dibujar el fade
	backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param->gameWidth, param->gameHeight);
	SDL_SetTextureBlendMode(backbuffer, SDL_BLENDMODE_BLEND);

	// Inicializa las variables
	init();
}

// Destructor
Fade::~Fade()
{
	SDL_DestroyTexture(backbuffer);
	backbuffer = nullptr;
}

// Inicializa las variables
void Fade::init()
{
	type = FADE_CENTER;
	enabled = false;
	finished = false;
	counter = 0;
	r = 0;
	g = 0;
	b = 0;
}

// Pinta una transición en pantalla
void Fade::render()
{
	if (enabled && !finished)
	{
		switch (type)
		{
		case FADE_FULLSCREEN:
		{
			SDL_SetTextureAlphaMod(backbuffer, std::min(counter * 4, 255));
			SDL_RenderCopy(renderer, backbuffer, nullptr, nullptr);

			break;
		}

		case FADE_CENTER:
		{
			SDL_SetRenderDrawColor(renderer, r, g, b, 64);

			for (int i = 0; i < counter; i++)
			{
				rect1.h = rect2.h = i * 4;
				rect2.y = param->gameHeight - (i * 4);

				SDL_RenderFillRect(renderer, &rect1);
				SDL_RenderFillRect(renderer, &rect2);
			}

			break;
		}

		case FADE_RANDOM_SQUARE:
		{
			for (Uint16 i = 0; i < 50; i++)
			{
				// Crea un color al azar
				r = 255 * (rand() % 2);
				g = 255 * (rand() % 2);
				b = 255 * (rand() % 2);
				SDL_SetRenderDrawColor(renderer, r, g, b, 64);

				// Dibujamos sobre el backbuffer
				SDL_SetRenderTarget(renderer, backbuffer);

				rect1.x = rand() % (param->gameWidth - rect1.w);
				rect1.y = rand() % (param->gameHeight - rect1.h);
				SDL_RenderFillRect(renderer, &rect1);

				// Volvemos a usar el renderizador de forma normal
				SDL_SetRenderTarget(renderer, nullptr);

				// Copiamos el backbuffer al renderizador
				SDL_RenderCopy(renderer, backbuffer, nullptr, nullptr);

				// Volcamos el renderizador en pantalla
				SDL_RenderPresent(renderer);
				SDL_Delay(100);
			}
			break;
		}

		default:
			break;
		}
	}

	// Pone el color en toda la textura
	if (finished)
	{
		SDL_SetRenderDrawColor(renderer, r, g, b, 255);
		SDL_RenderClear(renderer);
	}
}

// Actualiza las variables internas
void Fade::update()
{
	if (enabled)
	{
		counter++;

		switch (type)
		{
		case FADE_FULLSCREEN:
			if (counter >= 255 / 4)
			{
				finished = true;
			}
			break;

		case FADE_CENTER:
			if ((counter * 4) > param->gameHeight)
			{
				finished = true;
			}
			break;

		case FADE_RANDOM_SQUARE:
			break;
		}

		if (finished)
		{
			enabled = false;
		}
	}
}

// Activa el fade
void Fade::activate()
{
	enabled = true;
	finished = false;
	counter = 0;

	switch (type)
	{
	case FADE_FULLSCREEN:
	{
		// Dibujamos sobre el backbuffer
		SDL_Texture *temp = SDL_GetRenderTarget(renderer);
		SDL_SetRenderTarget(renderer, backbuffer);

		// Pintamos la textura con el color del fade
		SDL_SetRenderDrawColor(renderer, r, g, b, 255);
		SDL_RenderClear(renderer);

		// Vuelve a dejar el renderizador como estaba
		SDL_SetRenderTarget(renderer, temp);
		break;
	}

	case FADE_CENTER:
	{
		rect1 = {0, 0, param->gameWidth, 0};
		rect2 = {0, 0, param->gameWidth, 0};
		break;
	}

	case FADE_RANDOM_SQUARE:
	{
		rect1 = {0, 0, 32, 32};
		break;
	}
	}
}

// Comprueba si está activo
bool Fade::isEnabled()
{
	return enabled;
}

// Comprueba si ha terminado la transicion
bool Fade::hasEnded()
{
	return finished;
}

// Establece el tipo de fade
void Fade::setType(Uint8 type)
{
	this->type = type;
}

// Establece el color del fade
void Fade::setColor(Uint8 r, Uint8 g, Uint8 b)
{
	this->r = r;
	this->g = g;
	this->b = b;
}