#include "scoreboard.h"

// Constructor
Scoreboard::Scoreboard(SDL_Renderer *renderer, Screen *screen, Asset *asset, Lang *lang, options_t *options)
{
	// Copia los punteros
	this->renderer = renderer;
	this->screen = screen;
	this->asset = asset;
	this->lang = lang;
	this->options = options;

	// Inicializa variables
	stage = 1;
	score1 = 0;
	score2 = 0;
	mult1 = 1;
	mult2 = 1;
	hiScore = 0;
	power = 0;
	hiScoreName = "";
	color = {0, 0, 0};
	rect = {0, 0, 320, 40};

	// Recalcula las anclas de los elementos
	recalculateAnchors();

	// Crea objetos
	gamePowerMeterTexture = new Texture(renderer, asset->get("game_power_meter.png"));
	powerMeterSprite = new Sprite(offsetPowerMeter.x - 20, offsetPowerMeter.y, 40, 7, gamePowerMeterTexture, renderer);
	textScoreBoard = new Text(asset->get("8bithud.png"), asset->get("8bithud.txt"), renderer);

	// Crea la textura para dibujar el marcador
	background = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
	SDL_SetTextureBlendMode(background, SDL_BLENDMODE_BLEND);

	// Rellena la textura de fondo
	fillBackgroundTexture();
}

Scoreboard::~Scoreboard()
{
	gamePowerMeterTexture->unload();
	delete gamePowerMeterTexture;
	delete powerMeterSprite;
	delete textScoreBoard;
	SDL_DestroyTexture(background);
}

// Transforma un valor numérico en una cadena de 6 cifras
std::string Scoreboard::updateScoreText(Uint32 num)
{
	if ((num >= 0) && (num <= 9))
	{
		return ("000000" + std::to_string(num));
	}

	if ((num >= 10) && (num <= 99))
	{
		return ("00000" + std::to_string(num));
	}

	if ((num >= 100) && (num <= 999))
	{
		return ("0000" + std::to_string(num));
	}

	if ((num >= 1000) && (num <= 9999))
	{
		return ("000" + std::to_string(num));
	}

	if ((num >= 010000) && (num <= 99999))
	{
		return ("00" + std::to_string(num));
	}

	if ((num >= 100000) && (num <= 999999))
	{
		return ("0" + std::to_string(num));
	}

	if ((num >= 1000000) && (num <= 9999999))
	{
		return (std::to_string(num));
	}

	return (std::to_string(num));
}

// Pinta el marcador
void Scoreboard::render()
{
	fillBackgroundTexture();
	SDL_RenderCopy(renderer, background, nullptr, &rect);
}

// Establece el valor de la variable
void Scoreboard::setScore1(int score)
{
	score1 = score;
}

// Establece el valor de la variable
void Scoreboard::setScore2(int score)
{
	score2 = score;
}

// Establece el valor de la variable
void Scoreboard::setMult1(float mult)
{
	mult1 = mult;
}

// Establece el valor de la variable
void Scoreboard::setMult2(float mult)
{
	mult2 = mult;
}

// Establece el valor de la variable
void Scoreboard::setStage(int stage)
{
	this->stage = stage;
}

// Establece el valor de la variable
void Scoreboard::setHiScore(int hiScore)
{
	this->hiScore = hiScore;
}

// Establece el valor de la variable
void Scoreboard::setPower(float power)
{
	this->power = power;
}

// Establece el valor de la variable
void Scoreboard::setHiScoreName(std::string name)
{
	hiScoreName = name;
}

// Establece el valor de la variable
void Scoreboard::setColor(color_t color)
{
	this->color = color;
	fillBackgroundTexture();
}

// Establece el valor de la variable
void Scoreboard::setPos(SDL_Rect rect)
{
	this->rect = rect;

	// Recalcula las anclas de los elementos
	recalculateAnchors();

	powerMeterSprite->setPosX(offsetPowerMeter.x - 20);
	powerMeterSprite->setPosY(offsetPowerMeter.y);

	// Recrea la textura de fondo
	if (background)
	{
		SDL_DestroyTexture(background);
	}
	background = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_RGBA8888, SDL_TEXTUREACCESS_TARGET, rect.w, rect.h);
	SDL_SetTextureBlendMode(background, SDL_BLENDMODE_BLEND);
	fillBackgroundTexture();
}

// Rellena la textura de fondo
void Scoreboard::fillBackgroundTexture()
{
	// Cambia el destino del renderizador
	SDL_Texture *temp = SDL_GetRenderTarget(renderer);
	SDL_SetRenderTarget(renderer, background);

	// Dibuja el fondo del marcador
	SDL_SetRenderDrawColor(renderer, color.r, color.g, color.b, 255);
	SDL_RenderFillRect(renderer, nullptr);

	// PLAYER1 - SCORE
	textScoreBoard->writeCentered(offsetScoreP1Label.x, offsetScoreP1Label.y, lang->getText(53));
	textScoreBoard->writeCentered(offsetScoreP1.x, offsetScoreP1.y, updateScoreText(score1));

	// PLAYER1 - MULT
	textScoreBoard->writeCentered(offsetMultP1Label.x, offsetMultP1Label.y, lang->getText(55));
	textScoreBoard->writeCentered(offsetMultP1.x, offsetMultP1.y, std::to_string(mult1).substr(0, 3));

	// PLAYER2 - SCORE
	textScoreBoard->writeCentered(offsetScoreP2Label.x, offsetScoreP2Label.y, lang->getText(54));
	textScoreBoard->writeCentered(offsetScoreP2.x, offsetScoreP2.y, updateScoreText(score2));

	// PLAYER2 - MULT
	textScoreBoard->writeCentered(offsetMultP2Label.x, offsetMultP2Label.y, lang->getText(55));
	textScoreBoard->writeCentered(offsetMultP2.x, offsetMultP2.y, std::to_string(mult2).substr(0, 3));

	// STAGE
	textScoreBoard->writeCentered(offsetStage.x, offsetStage.y, lang->getText(57) + std::to_string(stage));

	// POWERMETER
	powerMeterSprite->setSpriteClip(0, 0, 40, 7);
	powerMeterSprite->render();
	powerMeterSprite->setSpriteClip(40, 0, int(power * 40.0f), 7);
	powerMeterSprite->render();

	// HI-SCORE
	textScoreBoard->writeCentered(offsetHiScoreLabel.x, offsetHiScoreLabel.y, lang->getText(56));
	textScoreBoard->writeCentered(offsetHiScore.x, offsetHiScore.y, hiScoreName + updateScoreText(hiScore));

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

// Recalcula las anclas de los elementos
void Scoreboard::recalculateAnchors()
{
	// Constantes para definir las zonas del marcador: 4 filas y 3 columnas
	const int rowSize = rect.h / 4;
	const int textHeight = 7;
	const int row1 = (rowSize * 0) + (textHeight / 2);
	const int row2 = (rowSize * 1) + (textHeight / 2) - 1;
	const int row3 = (rowSize * 2) + (textHeight / 2) - 2;
	const int row4 = (rowSize * 3) + (textHeight / 2) - 3;

	const int halfColSize = rect.w / 6;
	const int col1 = halfColSize;
	const int col2 = halfColSize * 3;
	const int col3 = halfColSize * 5;

	// Primera fila
	offsetScoreP1Label = {col1, row1};
	offsetStage = {col2, row1};
	offsetScoreP2Label = {col3, row1};

	// Segunda fila
	offsetScoreP1 = {col1, row2};
	offsetPowerMeter = {col2, row2};
	offsetScoreP2 = {col3, row2};

	// Tercera fila
	offsetMultP1Label = {col1, row3};
	offsetHiScoreLabel = {col2, row3};
	offsetMultP2Label = {col3, row3};

	// Cuarta fila
	offsetMultP1 = {col1, row4};
	offsetHiScore = {col2, row4};
	offsetMultP2 = {col3, row4};
}