#include "title.h"
#include <SDL2/SDL_events.h>  // Para SDL_PollEvent, SDL_Event, SDL_KEYDOWN
#include <SDL2/SDL_keycode.h> // Para SDLK_1, SDLK_2, SDLK_3, SDLK_4, SDLK_5
#include <SDL2/SDL_timer.h>	  // Para SDL_GetTicks
#include <stddef.h>			  // Para size_t
#include <string>			  // Para char_traits, operator+, basic_string
#include <vector>			  // Para vector
#include "define_buttons.h"	  // Para DefineButtons
#include "fade.h"			  // Para Fade, FadeType
#include "game_logo.h"		  // Para GameLogo
#include "global_inputs.h"	  // Para check, update
#include "input.h"			  // Para Input, InputType, INPUT_DO_NOT_ALLOW_R...
#include "jail_audio.h"		  // Para JA_GetMusicState, JA_FadeOutMusic, JA_...
#include "lang.h"			  // Para getText
#include "mouse.h"			  // Para handleEvent
#include "notifier.h"		  // Para Notifier
#include "options.h"		  // Para OptionsController, Options, options
#include "param.h"			  // Para Param, param, ParamGame, ParamTitle
#include "resource.h"		  // Para Resource
#include "screen.h"			  // Para Screen
#include "section.h"		  // Para Options, Name, name, AttractMode, options
#include "sprite.h"			  // Para Sprite
#include "text.h"			  // Para TEXT_CENTER, TEXT_SHADOW, Text
#include "texture.h"		  // Para Texture
#include "tiled_bg.h"		  // Para TiledBG, TiledBGMode
#include "utils.h"			  // Para Color, Zone, fade_color, no_color, BLOCK

// Constructor
Title::Title()
	: text_(Resource::get()->getText("smb2")),
	  fade_(std::make_unique<Fade>()),
	  tiled_bg_(std::make_unique<TiledBG>(param.game.game_area.rect, TiledBGMode::RANDOM)),
	  game_logo_(std::make_unique<GameLogo>(param.game.game_area.center_x, param.title.title_c_c_position)),
	  mini_logo_sprite_(std::make_unique<Sprite>(Resource::get()->getTexture("logo_jailgames_mini.png"))),
	  define_buttons_(std::make_unique<DefineButtons>()),
	  num_controllers_(Input::get()->getNumControllers()),
	  state_(TitleState::LOGO_ANIMATING)
{
	// Configura objetos
	game_logo_->enable();
	mini_logo_sprite_->setX(param.game.game_area.center_x - mini_logo_sprite_->getWidth() / 2);
	fade_->setColor(fade_color.r, fade_color.g, fade_color.b);
	fade_->setType(FadeType::RANDOM_SQUARE);
	fade_->setPostDuration(param.fade.post_duration);
	Resource::get()->getTexture("smb2.gif")->setPalette(1);

	// Asigna valores a otras variables
	section::options = section::Options::TITLE_1;
	const bool is_title_to_demo = (section::attract_mode == section::AttractMode::TITLE_TO_DEMO);
	next_section_ = is_title_to_demo ? section::Name::GAME_DEMO : section::Name::LOGO;
	section::attract_mode = is_title_to_demo ? section::AttractMode::TITLE_TO_LOGO : section::AttractMode::TITLE_TO_DEMO;
}

// Destructor
Title::~Title()
{
	Resource::get()->getTexture("smb2.gif")->setPalette(0);
	JA_StopChannel(-1);
}

// Actualiza las variables del objeto
void Title::update()
{
	constexpr int TICKS_SPEED = 15;

	if (SDL_GetTicks() - ticks_ > TICKS_SPEED)
	{
		// Actualiza el contador de ticks_
		ticks_ = SDL_GetTicks();

		// Actualiza el objeto screen
		Screen::get()->update();

		// Actualiza las variables de globalInputs
		globalInputs::update();

		// Comprueba el fundido
		fade_->update();
		if (fade_->hasEnded())
		{
			if (selection_ == section::Options::TITLE_TIME_OUT)
			{
				// El menu ha hecho time out
				section::name = next_section_;
			}
			else
			{
				// Se ha pulsado para jugar
				section::name = section::Name::GAME;
				section::options = selection_;
				JA_StopMusic();
			}
		}

		// Establece la lógica según el estado
		switch (state_)
		{
		case TitleState::LOGO_ANIMATING:
		{
			game_logo_->update();
			if (game_logo_->hasFinished())
			{
				state_ = TitleState::LOGO_FINISHED;
			}
			break;
		}
		case TitleState::LOGO_FINISHED:
		{
			// El contador solo sube si no estamos definiendo botones
			counter_ = define_buttons_->isEnabled() ? 0 : counter_ + 1;

			// Reproduce la música
			if ((JA_GetMusicState() == JA_MUSIC_INVALID) || (JA_GetMusicState() == JA_MUSIC_STOPPED))
			{
				JA_PlayMusic(Resource::get()->getMusic("title.ogg"));
			}

			// Actualiza el logo con el título del juego
			game_logo_->update();

			// Actualiza el mosaico de fondo
			tiled_bg_->update();

			if (counter_ == param.title.title_duration)
			{
				// El menu ha hecho time out
				fade_->setPostDuration(0);
				fade_->activate();
				selection_ = section::Options::TITLE_TIME_OUT;
			}

			break;
		}
		case TitleState::START_HAS_BEEN_PRESSED:
		{
			// Actualiza el logo con el título del juego
			game_logo_->update();

			// Actualiza el mosaico de fondo
			tiled_bg_->update();

			if (counter_ == 100)
			{
				fade_->activate();
			}
			++counter_;
			break;
		}

		default:
			break;
		}
	}
}

// Dibuja el objeto en pantalla
void Title::render()
{
	// Prepara para empezar a dibujar en la textura de juego
	Screen::get()->start();

	// Limpia la pantalla
	Screen::get()->clean(bg_color);

	// Dibuja el mosacico de fondo
	tiled_bg_->render();

	// Dibuja el logo con el título del juego
	game_logo_->render();

	constexpr Color shadow = Color(0x14, 0x87, 0xc4);

	if (state_ != TitleState::LOGO_ANIMATING)
	{
		// Mini logo
		const int pos1 = (param.game.height / 5 * 4) + BLOCK;
		const int pos2 = pos1 + mini_logo_sprite_->getHeight() + 3;
		mini_logo_sprite_->setY(pos1);
		mini_logo_sprite_->render();

		// Texto con el copyright
		text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, pos2, TEXT_COPYRIGHT, 1, no_color, 1, shadow);
	}

	if (state_ == TitleState::LOGO_FINISHED)
	{
		// 'PRESS TO PLAY'
		if (counter_ % 50 > 14 && !define_buttons_->isEnabled())
		{
			text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
		}
	}

	if (state_ == TitleState::START_HAS_BEEN_PRESSED)
	{
		// 'PRESS TO PLAY'
		if (counter_ % 10 > 4 && !define_buttons_->isEnabled())
		{
			text_->writeDX(TEXT_CENTER | TEXT_SHADOW, param.game.game_area.center_x, param.title.press_start_position, lang::getText(23), 1, no_color, 1, shadow);
		}
	}

	// Define Buttons
	define_buttons_->render();

	// Fade
	fade_->render();

	// Vuelca el contenido del renderizador en pantalla
	Screen::get()->render();
}

// Comprueba los eventos
void Title::checkEvents()
{
	// Comprueba el input para el resto de objetos
	define_buttons_->checkEvents();

	// Si define_buttons_ está habilitado, es él quien gestiona los eventos
	if (!define_buttons_->isEnabled())
	{
		SDL_Event event;
		while (SDL_PollEvent(&event))
		{
			// Evento de salida de la aplicación
			if (event.type == SDL_QUIT)
			{
				section::name = section::Name::QUIT;
				section::options = section::Options::QUIT_FROM_EVENT;
				break;
			}

			// Recarga las texturas
			else if (event.type == SDL_RENDER_DEVICE_RESET || event.type == SDL_RENDER_TARGETS_RESET)
			{
				reLoadTextures();
			}

			else if (event.type == SDL_KEYDOWN && event.key.repeat == 0)
			{
				switch (event.key.keysym.sym)
				{
				case SDLK_1: // Redefine los botones del mando #0
				{
					if (define_buttons_->enable(0))
						resetCounter();
					break;
				}
				case SDLK_2: // Redefine los botones del mando #1
				{
					if (define_buttons_->enable(1))
						resetCounter();
					break;
				}
				case SDLK_3: // Intercambia los mandos entre los dos jugadores
				{
					swapControllers();
					resetCounter();
					break;
				}
				case SDLK_4: // Intercambia la asignación del teclado
				{
					swapKeyboard();
					resetCounter();
					break;
				}
				case SDLK_5: // Muestra la asignacion de mandos y teclado
				{
					showControllers();
					resetCounter();
					break;
				}
				default:
					break;
				}
			}

			// Comprueba el cursor
			Mouse::handleEvent(event);
		}
	}
}

// Comprueba las entradas
void Title::checkInput()
{
	// Comprueba las entradas solo si no se estan definiendo los botones
	if (!define_buttons_->isEnabled())
	{
		// Comprueba todos los métodos de control
		for (const auto &controller : options.controllers)
		{
			// START
			if (Input::get()->checkInput(InputType::START, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index) &&
				!Input::get()->checkInput(InputType::SERVICE, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
			{
				if ((state_ == TitleState::LOGO_FINISHED || ALLOW_TITLE_ANIMATION_SKIP) && !fade_->isEnabled())
				{
					JA_PlaySound(Resource::get()->getSound("game_start.wav"));
					JA_FadeOutMusic(1500);
					switch (controller.player_id)
					{
					case 1:
						selection_ = section::Options::GAME_PLAY_1P;
						break;
					case 2:
						selection_ = section::Options::GAME_PLAY_2P;
						break;
					default:
						selection_ = section::Options::TITLE_TIME_OUT;
						break;
					}
					state_ = TitleState::START_HAS_BEEN_PRESSED;
					counter_ = 0;
					return;
				}
			}

			// SWAP_CONTROLLERS
			if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, controller.type, controller.index) &&
				Input::get()->checkInput(InputType::SWAP_CONTROLLERS, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
			{
				swapControllers();
				return;
			}

			// CONFIG
			if (Input::get()->checkInput(InputType::SERVICE, INPUT_ALLOW_REPEAT, controller.type, controller.index) &&
				Input::get()->checkInput(InputType::CONFIG, INPUT_DO_NOT_ALLOW_REPEAT, controller.type, controller.index))
			{
				define_buttons_->enable(controller.index);
				return;
			}
		}
	}

	// Comprueba los inputs que se pueden introducir en cualquier sección del juego
	globalInputs::check();
}

// Bucle para el titulo del juego
void Title::run()
{
	while (section::name == section::Name::TITLE)
	{
		checkInput();
		update();
		checkEvents(); // Tiene que ir antes del render
		render();
	}
}

// Recarga las texturas
void Title::reLoadTextures()
{
	game_logo_->reLoad();
	tiled_bg_->reLoad();
}

// Reinicia el contador interno
void Title::resetCounter() { counter_ = 0; }

// Intercambia la asignación de mandos a los jugadores
void Title::swapControllers()
{
	if (Input::get()->getNumControllers() == 0)
		return;

	swapOptionsControllers();
	showControllers();
}

// Intercambia el teclado de jugador
void Title::swapKeyboard()
{
	swapOptionsKeyboard();
	std::string text = lang::getText(100) + std::to_string(getPlayerWhoUsesKeyboard()) + ": " + lang::getText(69);
	Notifier::get()->show({text});
}

// Muestra información sobre los controles y los jugadores
void Title::showControllers()
{
	// Crea vectores de texto vacíos para un número máximo de mandos
	constexpr size_t NUM_CONTROLLERS = 2;
	std::vector<std::string> text(NUM_CONTROLLERS);
	std::vector<int> playerControllerIndex(NUM_CONTROLLERS, -1);

	// Obtiene de cada jugador el índice del mando que tiene asignado
	for (size_t i = 0; i < NUM_CONTROLLERS; ++i)
	{
		// Ejemplo: el jugador 1 tiene el mando 2
		playerControllerIndex.at(options.controllers.at(i).player_id - 1) = i;
	}

	// Genera el texto correspondiente
	for (size_t i = 0; i < NUM_CONTROLLERS; ++i)
	{
		const size_t index = playerControllerIndex.at(i);
		if (options.controllers.at(index).plugged)
		{
			text.at(i) = lang::getText(100) + std::to_string(i + 1) + ": " + options.controllers.at(index).name;
		}
	}

	// Muestra la notificación
	Notifier::get()->show({text.at(0), text.at(1)});
}