#include "fade.h"
#include <SDL2/SDL_blendmode.h> // for SDL_BLENDMODE_BLEND, SDL_BLENDMODE_NONE
#include <SDL2/SDL_pixels.h>	// for SDL_PIXELFORMAT_RGBA8888
#include <stdlib.h>				// for rand
#include <algorithm>			// for min, max
#include "param.h"				// for param
#include "utils.h"				// for Param, ParamGame, ParamFade

// Constructor
Fade::Fade(SDL_Renderer *renderer)
	: renderer(renderer)
{
	// Crea la textura donde dibujar el fade
	backbuffer = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, param.game.width, param.game.height);
	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 = FadeType::CENTER;
	mode = FadeMode::OUT;
	enabled = false;
	finished = false;
	counter = 0;
	r = 0;
	g = 0;
	b = 0;
	postDuration = 20;
	postCounter = 0;
	numSquaresWidth = param.fade.num_squares_width;
	numSquaresHeight = param.fade.num_squares_height;
	fadeRandomSquaresDelay = param.fade.random_squares_delay;
	fadeRandomSquaresMult = param.fade.random_squares_mult;
}

// Resetea algunas variables para volver a hacer el fade sin perder ciertos parametros
void Fade::reset()
{
	enabled = false;
	finished = false;
	counter = 0;
}

// Pinta una transición en pantalla
void Fade::render()
{
	if (enabled || finished)
	{
		SDL_RenderCopy(renderer, backbuffer, nullptr, nullptr);
	}
}

// Actualiza las variables internas
void Fade::update()
{
	if (enabled)
	{
		switch (type)
		{
		case FadeType::FULLSCREEN:
		{
			// Modifica la transparencia
			a = mode == FadeMode::OUT ? std::min(counter * 4, 255) : 255 - std::min(counter * 4, 255);

			SDL_SetTextureAlphaMod(backbuffer, a);

			// Comprueba si ha terminado
			if (counter >= 255 / 4)
			{
				finished = true;
			}

			break;
		}

		case FadeType::CENTER:
		{
			// Dibuja sobre el backbuffer
			auto *temp = SDL_GetRenderTarget(renderer);
			SDL_SetRenderTarget(renderer, backbuffer);

			SDL_SetRenderDrawColor(renderer, r, g, b, a);

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

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

			// Deja el renderizador como estaba
			SDL_SetRenderTarget(renderer, temp);

			// Comprueba si ha terminado
			if ((counter * 4) > param.game.height)
			{
				finished = true;
				a = 255;
			}
			break;
		}

		case FadeType::RANDOM_SQUARE:
		{
			if (counter % fadeRandomSquaresDelay == 0)
			{
				// Dibuja sobre el backbuffer
				auto *temp = SDL_GetRenderTarget(renderer);
				SDL_SetRenderTarget(renderer, backbuffer);

				SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
				SDL_SetRenderDrawColor(renderer, r, g, b, a);

				// Dibuja el cuadrado correspondiente
				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]);
				}

				SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);

				// Deja el renderizador como estaba
				SDL_SetRenderTarget(renderer, temp);
			}

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

			break;
		}

		case FadeType::VENETIAN:
		{
			// Counter debe ir de 0 a 150
			if (square.back().h < param.fade.venetian_size)
			{
				// Dibuja sobre el backbuffer
				auto *temp = SDL_GetRenderTarget(renderer);
				SDL_SetRenderTarget(renderer, backbuffer);

				SDL_SetRenderDrawColor(renderer, r, g, b, a);
				for (auto rect : square)
				{
					SDL_RenderFillRect(renderer, &rect);
				}

				// Deja el renderizador como estaba
				SDL_SetRenderTarget(renderer, temp);

				const auto h = counter / 3;
				for (int i = 0; i < (int)square.size(); ++i)
				{
					// A partir del segundo rectangulo se pinta en función del anterior
					square[i].h = i == 0 ? h : std::max(square[i - 1].h - 3, 0);
				}
			}
			else
			{
				finished = true;
			}

			break;
		}
		}

		if (finished)
		{
			// Actualiza el contador
			postCounter == postDuration ? enabled = false : postCounter++;

			// Deja el backbuffer todo del mismo color
			cleanBackbuffer(r, g, b, a);
		}

		counter++;
	}
}

// Activa el fade
void Fade::activate()
{
	// Si ya está habilitado, no hay que volverlo a activar
	if (enabled)
	{
		return;
	}

	enabled = true;
	finished = false;
	counter = 0;
	postCounter = 0;

	switch (type)
	{
	case FadeType::FULLSCREEN:
	{
		// Pinta el backbuffer de color sólido
		cleanBackbuffer(r, g, b, 255);
		break;
	}

	case FadeType::CENTER:
	{
		rect1 = {0, 0, param.game.width, 0};
		rect2 = {0, 0, param.game.width, 0};
		a = 64;
		break;
	}

	case FadeType::RANDOM_SQUARE:
	{
		rect1 = {0, 0, param.game.width / numSquaresWidth, param.game.height / 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
		auto num = numSquaresWidth * numSquaresHeight;
		while (num > 1)
		{
			auto num_arreu = rand() % num;
			SDL_Rect temp = square[num_arreu];
			square[num_arreu] = square[num - 1];
			square[num - 1] = temp;
			num--;
		}

		// Limpia la textura
		auto *temp = SDL_GetRenderTarget(renderer);
		SDL_SetRenderTarget(renderer, backbuffer);
		a = mode == FadeMode::OUT ? 0 : 255;
		SDL_SetRenderDrawColor(renderer, r, g, b, a);
		SDL_RenderClear(renderer);
		SDL_SetRenderTarget(renderer, temp);

		// Deja el color listo para usar
		a = mode == FadeMode::OUT ? 255 : 0;

		break;
	}

	case FadeType::VENETIAN:
	{
		cleanBackbuffer(0, 0, 0, 0);
		rect1 = {0, 0, param.game.width, 0};
		square.clear();
		a = 255;

		// Añade los cuadrados al vector
		const int max = param.game.height / param.fade.venetian_size;

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

		break;
	}
	}
}

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

// Comprueba si ha terminado la transicion
bool Fade::hasEnded() const
{
	// Ha terminado cuando ha finalizado la transición y se ha deshabilitado
	return !enabled && finished;
}

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

// Establece el modo de fade
void Fade::setMode(FadeMode mode)
{
	this->mode = mode;
}

// 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;
}

// Limpia el backbuffer
void Fade::cleanBackbuffer(Uint8 r, Uint8 g, Uint8 b, Uint8 a)
{
	// Dibujamos sobre el backbuffer
	auto *temp = SDL_GetRenderTarget(renderer);
	SDL_SetRenderTarget(renderer, backbuffer);

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

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