#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;
	postDuration = 20;
	postCounter = 0;
	numSquaresWidth = param->numSquaresWidth;
	numSquaresHeight = param->numSquaresHeight;
	fadeRandomSquaresDelay = param->fadeRandomSquaresDelay;
	fadeRandomSquaresMult = param->fadeRandomSquaresMult;
}

// 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:
		{
			SDL_RenderCopy(renderer, backbuffer, nullptr, nullptr);

			break;
		}

		case FADE_VENETIAN:
		{
			SDL_SetRenderDrawColor(renderer, r, g, b, 0xFF);
			for (auto rect : square)
			{
				SDL_RenderFillRect(renderer, &rect);
			}

			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)
	{
		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:
		{
			if (counter % fadeRandomSquaresDelay == 0)
			{
				// Dibujamos sobre el backbuffer
				SDL_Texture *temp = SDL_GetRenderTarget(renderer);
				SDL_SetRenderTarget(renderer, backbuffer);

				// Dibuja el cuadrado correspondiente
				SDL_SetRenderDrawColor(renderer, r, g, b, 255);
				const int index = std::min(counter / fadeRandomSquaresDelay, (numSquaresWidth * numSquaresHeight) - 1);
				for (int i = 0; i < fadeRandomSquaresMult; ++i)
				{
					const int index2 = std::min(index * fadeRandomSquaresMult + i, (int)square.size() - 1);
					SDL_RenderFillRect(renderer, &square[index2]);
				}

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

			if (counter * fadeRandomSquaresMult / fadeRandomSquaresDelay >= numSquaresWidth * numSquaresHeight)
			{
				finished = true;
			}

			break;
		}

		case FADE_VENETIAN:
		{
			// Counter debe ir de 0 a 150
			if (square.back().h < param->venetianSize)
			{
				const Uint8 h = counter / 3;
				for (int i = 0; i < (int)square.size(); ++i)
				{
					if (i == 0)
					{
						square[i].h = h;
					}
					else
					{
						square[i].h = std::max(square[i - 1].h - 3, 0);
					}
				}
			}
			else
			{
				finished = true;
			}

			break;
		}
		}

		if (finished)
		{
			if (postCounter == postDuration)
			{
				enabled = false;
			}
			else
			{
				postCounter++;
			}
		}

		counter++;
	}
}

// Activa el fade
void Fade::activate()
{
	enabled = true;
	finished = false;
	counter = 0;
	postCounter = 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, param->gameWidth / numSquaresWidth, param->gameHeight / numSquaresHeight};
		square.clear();

		// Añade los cuadrados al vector
		for (int i = 0; i < numSquaresWidth * numSquaresHeight; ++i)
		{
			rect1.x = (i % numSquaresWidth) * rect1.w;
			rect1.y = (i / numSquaresWidth) * rect1.h;
			square.push_back(rect1);
		}

		// Desordena el vector de cuadrados
		int num = numSquaresWidth * numSquaresHeight;
		while (num > 1)
		{
			int num_arreu = rand() % num;
			SDL_Rect temp = square[num_arreu];
			square[num_arreu] = square[num - 1];
			square[num - 1] = temp;
			num--;
		}

		// Limpia la textura
		SDL_Texture *temp = SDL_GetRenderTarget(renderer);
		SDL_SetRenderTarget(renderer, backbuffer);
		SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
		SDL_RenderClear(renderer);
		SDL_SetRenderTarget(renderer, temp);

		break;
	}

	case FADE_VENETIAN:
	{
		rect1 = {0, 0, param->gameWidth, 0};
		square.clear();

		// Añade los cuadrados al vector
		const int max = param->gameHeight / param->venetianSize;

		for (int i = 0; i < max; ++i)
		{
			rect1.y = i * param->venetianSize;
			square.push_back(rect1);
		}

		break;
	}
	}
}

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

// Comprueba si ha terminado la transicion
bool Fade::hasEnded()
{
	// Ha terminado cuando ha finalizado la transición y se ha deshabilitado
	return !enabled && 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;
}

// Establece la duración posterior
void Fade::setPost(int value)
{
	postDuration = value;
}