#include "input.h"
#include <SDL3/SDL_error.h>	   // Para SDL_GetError
#include <SDL3/SDL_init.h>	   // Para SDL_INIT_GAMEPAD, SDL_InitSubSystem
#include <SDL3/SDL_keyboard.h> // Para SDL_GetKeyboardState
#include <SDL3/SDL_log.h>	   // Para SDL_LogInfo, SDL_LogCategory, SDL_Log...
#include <algorithm>		   // Para find
#include <iterator>			   // Para distance
#include <unordered_map>	   // Para unordered_map, operator==, _Node_cons...
#include <utility>			   // Para pair

// [SINGLETON]
Input *Input::input_ = nullptr;

// [SINGLETON] Crearemos el objeto con esta función estática
void Input::init(const std::string &game_controller_db_path)
{
	Input::input_ = new Input(game_controller_db_path);
}

// [SINGLETON] Destruiremos el objeto con esta función estática
void Input::destroy()
{
	delete Input::input_;
}

// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
Input *Input::get()
{
	return Input::input_;
}

// Constructor
Input::Input(const std::string &game_controller_db_path)
	: game_controller_db_path_(game_controller_db_path)
{
	// Inicializa el subsistema SDL_INIT_GAMEPAD
	initSDL();

	// Inicializa los vectores
	key_bindings_.resize(static_cast<int>(InputAction::SIZE), KeyBindings());
	controller_bindings_.resize(num_gamepads_, std::vector<ControllerBindings>(static_cast<int>(InputAction::SIZE), ControllerBindings()));

	// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
	button_inputs_ = {InputAction::FIRE_LEFT, InputAction::FIRE_CENTER, InputAction::FIRE_RIGHT, InputAction::START};
}

// Asigna inputs a teclas
void Input::bindKey(InputAction input, SDL_Scancode code)
{
	key_bindings_.at(static_cast<int>(input)).scancode = code;
}

// Asigna inputs a botones del mando
void Input::bindGameControllerButton(int controller_index, InputAction input, SDL_GamepadButton button)
{
	if (controller_index < num_gamepads_)
	{
		controller_bindings_.at(controller_index).at(static_cast<int>(input)).button = button;
	}
}

// Asigna inputs a botones del mando
void Input::bindGameControllerButton(int controller_index, InputAction input_target, InputAction input_source)
{
	if (controller_index < num_gamepads_)
	{
		controller_bindings_.at(controller_index).at(static_cast<int>(input_target)).button = controller_bindings_.at(controller_index).at(static_cast<int>(input_source)).button;
	}
}

// Comprueba si un input esta activo
bool Input::checkInput(InputAction input, bool repeat, InputDeviceToUse device, int controller_index)
{
	bool success_keyboard = false;
	bool success_controller = false;
	const int input_index = static_cast<int>(input);

	if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
	{
		const bool *keyStates = SDL_GetKeyboardState(nullptr);

		if (repeat)
		{
			success_keyboard = keyStates[key_bindings_[input_index].scancode] != 0;
		}
		else
		{
			if (!key_bindings_[input_index].active)
			{
				if (keyStates[key_bindings_[input_index].scancode] != 0)
				{
					key_bindings_[input_index].active = true;
					success_keyboard = true;
				}
				else
				{
					success_keyboard = false;
				}
			}
			else
			{
				if (keyStates[key_bindings_[input_index].scancode] == 0)
				{
					key_bindings_[input_index].active = false;
				}
				success_keyboard = false;
			}
		}
	}

	if (gameControllerFound() && controller_index >= 0 && controller_index < num_gamepads_)
	{
		if ((device == InputDeviceToUse::CONTROLLER) || (device == InputDeviceToUse::ANY))
		{
			success_controller = checkAxisInput(input, controller_index, repeat);

			if (!success_controller)
			{
				if (repeat)
				{
					success_controller = SDL_GetGamepadButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) != 0;
				}
				else
				{
					if (!controller_bindings_.at(controller_index).at(input_index).active)
					{
						if (SDL_GetGamepadButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) != 0)
						{
							controller_bindings_.at(controller_index).at(input_index).active = true;
							success_controller = true;
						}
						else
						{
							success_controller = false;
						}
					}
					else
					{
						if (SDL_GetGamepadButton(connected_controllers_.at(controller_index), controller_bindings_.at(controller_index).at(input_index).button) == 0)
						{
							controller_bindings_.at(controller_index).at(input_index).active = false;
						}
						success_controller = false;
					}
				}
			}
		}
	}

	return (success_keyboard || success_controller);
}

// Comprueba si hay almenos un input activo
bool Input::checkAnyInput(InputDeviceToUse device, int controller_index)
{
	if (device == InputDeviceToUse::KEYBOARD || device == InputDeviceToUse::ANY)
	{
		const bool *mKeystates = SDL_GetKeyboardState(nullptr);

		for (int i = 0; i < (int)key_bindings_.size(); ++i)
		{
			if (mKeystates[key_bindings_[i].scancode] != 0 && !key_bindings_[i].active)
			{
				key_bindings_[i].active = true;
				return true;
			}
		}
	}

	if (gameControllerFound())
	{
		if (device == InputDeviceToUse::CONTROLLER || device == InputDeviceToUse::ANY)
		{
			for (int i = 0; i < (int)controller_bindings_.size(); ++i)
			{
				if (SDL_GetGamepadButton(connected_controllers_[controller_index], controller_bindings_[controller_index][i].button) != 0 && !controller_bindings_[controller_index][i].active)
				{
					controller_bindings_[controller_index][i].active = true;
					return true;
				}
			}
		}
	}

	return false;
}

// Comprueba si hay algún botón pulsado. Devuelve 0 en caso de no encontrar nada o el indice del dispositivo + 1. Se hace así para poder gastar el valor devuelto como un valor "booleano"
int Input::checkAnyButtonPressed(bool repeat)
{
	// Si está pulsado el botón de servicio, ningún botón se puede considerar pulsado
	if (checkInput(InputAction::SERVICE, INPUT_ALLOW_REPEAT, InputDeviceToUse::ANY))
	{
		return 0;
	}

	// Solo comprueba los botones definidos previamente
	for (auto bi : button_inputs_)
	{
		// Comprueba el teclado
		if (checkInput(bi, repeat, InputDeviceToUse::KEYBOARD))
		{
			return 1;
		}

		// Comprueba los mandos
		for (int i = 0; i < num_gamepads_; ++i)
		{
			if (checkInput(bi, repeat, InputDeviceToUse::CONTROLLER, i))
			{
				return i + 1;
			}
		}
	}

	return 0;
}

// Busca si hay mandos conectados
bool Input::discoverGameControllers()
{
	bool found = false;

	if (SDL_AddGamepadMappingsFromFile(game_controller_db_path_.c_str()) < 0)
	{
		SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Error: could not load %s file: %s", game_controller_db_path_.c_str(), SDL_GetError());
	}

	SDL_GetJoysticks(&num_joysticks_);
	num_gamepads_ = 0;

	// Cuenta el número de mandos
	joysticks_.clear();
	for (int i = 0; i < num_joysticks_; ++i)
	{
		auto joy = SDL_OpenJoystick(i);
		joysticks_.push_back(joy);
		if (SDL_IsGamepad(i))
		{
			num_gamepads_++;
		}
	}

	SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, ">> LOOKING FOR GAME CONTROLLERS");
	if (num_joysticks_ != num_gamepads_)
	{
		SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Joysticks found: %d", num_joysticks_);
		SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Gamepads found : %d", num_gamepads_);
	}
	else
	{
		SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "Gamepads found: %d", num_gamepads_);
	}

	if (num_gamepads_ > 0)
	{
		found = true;

		for (int i = 0; i < num_gamepads_; i++)
		{
			// Abre el mando y lo añade a la lista
			auto pad = SDL_OpenGamepad(i);
			if (SDL_GamepadConnected(pad) == 1)
			{
				connected_controllers_.push_back(pad);
				const std::string name = SDL_GetGamepadNameForID(i);
				SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "#%d: %s", i, name.c_str());
				controller_names_.push_back(name);
			}
			else
			{
				SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GetError() = %s", SDL_GetError());
			}
		}

		SDL_SetGamepadEventsEnabled(true);
	}

	SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n>> FINISHED LOOKING FOR GAME CONTROLLERS");
	return found;
}

// Comprueba si hay algun mando conectado
bool Input::gameControllerFound() { return num_gamepads_ > 0 ? true : false; }

// Obten el nombre de un mando de juego
std::string Input::getControllerName(int controller_index) const { return num_gamepads_ > 0 ? controller_names_.at(controller_index) : std::string(); }

// Obten el número de mandos conectados
int Input::getNumControllers() const { return num_gamepads_; }

// Obtiene el indice del controlador a partir de un event.id
int Input::getJoyIndex(SDL_JoystickID id) const
{
	for (int i = 0; i < num_joysticks_; ++i)
	{
		if (SDL_GetJoystickID(joysticks_[i]) == id)
		{
			return i;
		}
	}
	return -1;
}

// Muestra por consola los controles asignados
void Input::printBindings(InputDeviceToUse device, int controller_index) const
{
	if (device == InputDeviceToUse::ANY || device == InputDeviceToUse::KEYBOARD)
	{
		return;
	}

	if (device == InputDeviceToUse::CONTROLLER)
	{
		if (controller_index >= num_gamepads_)
		{
			return;
		}

		// Muestra el nombre del mando
		SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "\n%s", controller_names_.at(controller_index).c_str());

		// Muestra los botones asignados
		for (auto bi : button_inputs_)
		{
			SDL_LogInfo(SDL_LOG_CATEGORY_APPLICATION, "%s : %d", to_string(bi).c_str(), controller_bindings_.at(controller_index).at(static_cast<int>(bi)).button);
		}
	}
}

// Obtiene el SDL_GamepadButton asignado a un input
SDL_GamepadButton Input::getControllerBinding(int controller_index, InputAction input) const
{
	return controller_bindings_[controller_index][static_cast<int>(input)].button;
}

// Obtiene el indice a partir del nombre del mando
int Input::getIndexByName(const std::string &name) const
{
	auto it = std::find(controller_names_.begin(), controller_names_.end(), name);
	return it != controller_names_.end() ? std::distance(controller_names_.begin(), it) : -1;
}

// Convierte un InputAction a std::string
std::string Input::to_string(InputAction input) const
{
	switch (input)
	{
	case InputAction::FIRE_LEFT:
		return "input_fire_left";
	case InputAction::FIRE_CENTER:
		return "input_fire_center";
	case InputAction::FIRE_RIGHT:
		return "input_fire_right";
	case InputAction::START:
		return "input_start";
	case InputAction::SERVICE:
		return "input_service";
	default:
		return "";
	}
}

// Convierte un std::string a InputAction
InputAction Input::to_inputs_e(const std::string &name) const
{
	static const std::unordered_map<std::string, InputAction> inputMap = {
		{"input_fire_left", InputAction::FIRE_LEFT},
		{"input_fire_center", InputAction::FIRE_CENTER},
		{"input_fire_right", InputAction::FIRE_RIGHT},
		{"input_start", InputAction::START},
		{"input_service", InputAction::SERVICE}};

	auto it = inputMap.find(name);
	return it != inputMap.end() ? it->second : InputAction::NONE;
}

// Comprueba el eje del mando
bool Input::checkAxisInput(InputAction input, int controller_index, bool repeat)
{
	// Umbral para considerar el eje como activo
	const Sint16 threshold = 30000;
	bool axis_active_now = false;

	switch (input)
	{
	case InputAction::LEFT:
		axis_active_now = SDL_GetGamepadAxis(connected_controllers_[controller_index], SDL_GAMEPAD_AXIS_LEFTX) < -threshold;
		break;
	case InputAction::RIGHT:
		axis_active_now = SDL_GetGamepadAxis(connected_controllers_[controller_index], SDL_GAMEPAD_AXIS_LEFTX) > threshold;
		break;
	case InputAction::UP:
		axis_active_now = SDL_GetGamepadAxis(connected_controllers_[controller_index], SDL_GAMEPAD_AXIS_LEFTY) < -threshold;
		break;
	case InputAction::DOWN:
		axis_active_now = SDL_GetGamepadAxis(connected_controllers_[controller_index], SDL_GAMEPAD_AXIS_LEFTY) > threshold;
		break;
	default:
		return false;
	}

	// Referencia al binding correspondiente
	auto &binding = controller_bindings_.at(controller_index).at(static_cast<int>(input));

	if (repeat)
	{
		// Si se permite repetir, simplemente devolvemos el estado actual
		return axis_active_now;
	}
	else
	{
		// Si no se permite repetir, aplicamos la lógica de transición
		if (axis_active_now && !binding.axis_active)
		{
			// Transición de inactivo a activo
			binding.axis_active = true;
			return true;
		}
		else if (!axis_active_now && binding.axis_active)
		{
			// Transición de activo a inactivo
			binding.axis_active = false;
		}
		// Mantener el estado actual
		return false;
	}
}

void Input::initSDL()
{
	if (SDL_WasInit(SDL_INIT_GAMEPAD) != 1)
	{
		if (!SDL_InitSubSystem(SDL_INIT_GAMEPAD))
		{
			SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "SDL_GAMEPAD could not initialize! SDL Error: %s", SDL_GetError());
		}
		else
		{
			SDL_LogInfo(SDL_LOG_CATEGORY_TEST, "\n** SDL_GAMEPAD: INITIALIZING");
			discoverGameControllers();
			SDL_LogInfo(SDL_LOG_CATEGORY_TEST, "** SDL_GAMEPAD: INITIALIZATION COMPLETE\n");
		}
	}
}