#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 "screen.h"
#include "utils.h"				// for Param, ParamGame, ParamFade

// Constructor
Fade::Fade()
	: renderer_(Screen::get()->getRenderer())
{
	// 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;
	a_ = 0;
	post_duration_ = 20;
	post_counter_ = 0;
	num_squares_width_ = param.fade.num_squares_width;
	num_squares_height_ = param.fade.num_squares_height;
	fade_random_squares_delay_ = param.fade.random_squares_delay;
	fade_random_squares_mult_ = 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_ % fade_random_squares_delay_ == 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_ / fade_random_squares_delay_, (num_squares_width_ * num_squares_height_) - 1);
				for (int i = 0; i < fade_random_squares_mult_; ++i)
				{
					const int index2 = std::min(index * fade_random_squares_mult_ + 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_ * fade_random_squares_mult_ / fade_random_squares_delay_ >= num_squares_width_ * num_squares_height_)
			{
				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
			post_counter_ == post_duration_ ? enabled_ = false : post_counter_++;

			// 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;
	post_counter_ = 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 / num_squares_width_, param.game.height / num_squares_height_};
		square_.clear();

		// Añade los cuadrados al vector
		for (int i = 0; i < num_squares_width_ * num_squares_height_; ++i)
		{
			rect1_.x = (i % num_squares_width_) * rect1_.w;
			rect1_.y = (i / num_squares_width_) * rect1_.h;
			square_.push_back(rect1_);
		}

		// Desordena el vector de cuadrados
		auto num = num_squares_width_ * num_squares_height_;
		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)
{
	type_ = type;
}

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

// Establece el color del fade
void Fade::setColor(Uint8 r, Uint8 g, Uint8 b)
{
	r_ = r;
	g_ = g;
	b_ = b;
}

// Establece la duración posterior
void Fade::setPost(int value)
{
	post_duration_ = 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);
}