#include "input.h"
#include <SDL2/SDL.h>		   // para SDL_INIT_GAMECONTROLLER, SDL_InitSubS...
#include <SDL2/SDL_error.h>	   // para SDL_GetError
#include <SDL2/SDL_events.h>   // para SDL_ENABLE
#include <SDL2/SDL_keyboard.h> // para SDL_GetKeyboardState
#include <iostream>			   // para basic_ostream, operator<<, cout, basi...

// [SINGLETON] Hay que definir las variables estáticas, desde el .h sólo la hemos declarado
Input *Input::input_ = nullptr;

// [SINGLETON] Crearemos el objeto input 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 input con esta función estática
void Input::destroy()
{
	delete Input::input_;
}

// [SINGLETON] Con este método obtenemos el objeto input 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),
	  enabled_(true)
{
	// Busca si hay mandos conectados
	discoverGameControllers();

	// Inicializa las vectores
	KeyBindings kb;
	kb.scancode = 0;
	kb.active = false;
	key_bindings_.resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), kb);

	ControllerBindings gcb;
	gcb.button = SDL_CONTROLLER_BUTTON_INVALID;
	gcb.active = false;
	controller_bindings_.resize(num_gamepads_);
	for (int i = 0; i < num_gamepads_; ++i)
	{
		controller_bindings_[i].resize(static_cast<int>(InputType::NUMBER_OF_INPUTS), gcb);
	}

	// Listado de los inputs usados para jugar, excluyendo botones para la interfaz
	game_inputs_.clear();
	game_inputs_.push_back(InputType::FIRE_LEFT);
	game_inputs_.push_back(InputType::FIRE_CENTER);
	game_inputs_.push_back(InputType::FIRE_RIGHT);
	game_inputs_.push_back(InputType::UP);
	game_inputs_.push_back(InputType::DOWN);
	game_inputs_.push_back(InputType::LEFT);
	game_inputs_.push_back(InputType::RIGHT);

	// Listado de los inputs para jugar que utilizan botones, ni palancas ni crucetas
	button_inputs_.clear();
	button_inputs_.push_back(InputType::FIRE_LEFT);
	button_inputs_.push_back(InputType::FIRE_CENTER);
	button_inputs_.push_back(InputType::FIRE_RIGHT);
	button_inputs_.push_back(InputType::START);
}

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

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

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

// Comprueba si un input esta activo
bool Input::checkInput(InputType input, bool repeat, int device, int controller_index)
{
	if (!enabled_)
	{
		return false;
	}

	bool success_keyboard = false;
	bool success_controller = false;
	const int input_index = static_cast<int>(input);

	if (device == INPUT_USE_ANY)
	{
		controller_index = 0;
	}

	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
	{
		const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);

		if (repeat)
		{
			if (keyStates[key_bindings_[input_index].scancode] != 0)
			{
				success_keyboard = true;
			}
			else
			{
				success_keyboard = false;
			}
		}
		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;
				}
				else
				{
					success_keyboard = false;
				}
			}
		}
	}

	if (gameControllerFound() && controller_index < num_gamepads_)
		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
		{
			success_controller = checkAxisInput(input, controller_index);
			if (!success_controller)
			{
				if (repeat)
				{
					if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
					{
						success_controller = true;
					}
					else
					{
						success_controller = false;
					}
				}
				else
				{
					if (!controller_bindings_[controller_index][input_index].active)
					{
						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
						{
							controller_bindings_[controller_index][input_index].active = true;
							success_controller = true;
						}
						else
						{
							success_controller = false;
						}
					}
					else
					{
						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) == 0)
						{
							controller_bindings_[controller_index][input_index].active = false;
							success_controller = false;
						}
						else
						{
							success_controller = false;
						}
					}
				}
			}
		}

	return (success_keyboard || success_controller);
}

// Comprueba si un input con modificador esta activo
bool Input::checkModInput(InputType input_mod, InputType input, bool repeat, int device, int controller_index)
{
	if (!enabled_ || controller_index >= num_gamepads_ || !checkInput(input_mod, INPUT_ALLOW_REPEAT, device, controller_index))
	{
		return false;
	}

	bool success_keyboard = false;
	bool success_controller = false;
	const int input_index = static_cast<int>(input);

	if (device == INPUT_USE_ANY)
	{
		controller_index = 0;
	}

	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
	{
		const Uint8 *keyStates = SDL_GetKeyboardState(nullptr);

		if (repeat)
		{
			if (keyStates[key_bindings_[input_index].scancode] != 0)
			{
				success_keyboard = true;
			}
			else
			{
				success_keyboard = false;
			}
		}
		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;
				}
				else
				{
					success_keyboard = false;
				}
			}
		}
	}

	if (gameControllerFound() && controller_index < num_gamepads_)
		if ((device == INPUT_USE_GAMECONTROLLER) || (device == INPUT_USE_ANY))
		{
			success_controller = checkAxisInput(input, controller_index);
			if (!success_controller)
			{
				if (repeat)
				{
					if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
					{
						success_controller = true;
					}
					else
					{
						success_controller = false;
					}
				}
				else
				{
					if (!controller_bindings_[controller_index][input_index].active)
					{
						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) != 0)
						{
							controller_bindings_[controller_index][input_index].active = true;
							success_controller = true;
						}
						else
						{
							success_controller = false;
						}
					}
					else
					{
						if (SDL_GameControllerGetButton(connected_controllers_[controller_index], controller_bindings_[controller_index][input_index].button) == 0)
						{
							controller_bindings_[controller_index][input_index].active = false;
							success_controller = false;
						}
						else
						{
							success_controller = false;
						}
					}
				}
			}
		}

	return (success_keyboard || success_controller);
}

// Comprueba si hay almenos un input activo
bool Input::checkAnyInput(int device, int controller_index)
{
	if (device == INPUT_USE_ANY)
	{
		controller_index = 0;
	}

	if (device == INPUT_USE_KEYBOARD || device == INPUT_USE_ANY)
	{
		const Uint8 *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 == INPUT_USE_GAMECONTROLLER || device == INPUT_USE_ANY)
		{
			for (int i = 0; i < (int)controller_bindings_.size(); ++i)
			{
				if (SDL_GameControllerGetButton(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(InputType::SERVICE, INPUT_ALLOW_REPEAT, INPUT_USE_ANY))
	{
		return 0;
	}

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

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

	return 0;
}

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

	if (SDL_WasInit(SDL_INIT_GAMECONTROLLER) != 1)
	{
		SDL_InitSubSystem(SDL_INIT_GAMECONTROLLER);
	}

	if (SDL_GameControllerAddMappingsFromFile(game_controller_db_path_.c_str()) < 0)
	{
		{
			std::cout << "Error, could not load " << game_controller_db_path_.c_str() << " file: " << SDL_GetError() << std::endl;
		}
	}

	num_joysticks_ = SDL_NumJoysticks();
	num_gamepads_ = 0;

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

	std::cout << "\n** LOOKING FOR GAME CONTROLLERS" << std::endl;
	// std::cout << "  " << num_joysticks_ << " joysticks found" << std::endl;
	std::cout << "Gamepads found: " << num_gamepads_ << std::endl;

	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_GameControllerOpen(i);
			if (SDL_GameControllerGetAttached(pad) == 1)
			{
				connected_controllers_.push_back(pad);
				const std::string name = SDL_GameControllerNameForIndex(i);
				{
					std::cout << "#" << i << ": " << name << std::endl;
				}
				controller_names_.push_back(name);
			}
			else
			{
				{
					std::cout << "SDL_GetError() = " << SDL_GetError() << std::endl;
				}
			}
		}

		SDL_GameControllerEventState(SDL_ENABLE);
	}

	std::cout << "\n** FINISHED LOOKING FOR GAME CONTROLLERS" << std::endl;

	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_[controller_index] : "";
}

// 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(int id) const
{
	for (int i = 0; i < num_joysticks_; ++i)
	{
		if (SDL_JoystickInstanceID(joysticks_[i]) == id)
		{
			return i;
		}
	}
	return -1;
}

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

	if (device == INPUT_USE_GAMECONTROLLER)
	{
		if (controller_index >= num_gamepads_)
		{
			return;
		}

		// Muestra el nombre del mando
		std::cout << "\n"
				  << controller_names_[controller_index] << std::endl;

		// Muestra los botones asignados
		for (auto bi : button_inputs_)
		{
			std::cout << to_string(bi) << " : " << controller_bindings_[controller_index][static_cast<int>(bi)].button << std::endl;
		}
	}
}

// Obtiene el SDL_GameControllerButton asignado a un input
SDL_GameControllerButton Input::getControllerBinding(int controller_index, InputType 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
{
	for (int i = 0; i < num_gamepads_; ++i)
	{
		if (controller_names_[i] == name)
		{
			return i;
		}
	}
	return -1;
}

// Convierte un InputType a std::string
std::string Input::to_string(InputType input) const
{
	if (input == InputType::FIRE_LEFT)
	{
		return "input_fire_left";
	}

	if (input == InputType::FIRE_CENTER)
	{
		return "input_fire_center";
	}

	if (input == InputType::FIRE_RIGHT)
	{
		return "input_fire_right";
	}

	if (input == InputType::START)
	{
		return "input_start";
	}

	if (input == InputType::SERVICE)
	{
		return "input_service";
	}

	return "";
}

// Convierte un std::string a InputType
InputType Input::to_inputs_e(const std::string &name) const
{
	if (name == "input_fire_left")
	{
		return InputType::FIRE_LEFT;
	}

	if (name == "input_fire_center")
	{
		return InputType::FIRE_CENTER;
	}

	if (name == "input_fire_right")
	{
		return InputType::FIRE_RIGHT;
	}

	if (name == "input_start")
	{
		return InputType::START;
	}

	if (name == "input_service")
	{
		return InputType::SERVICE;
	}

	return InputType::NONE;
}

// Comprueba el eje del mando
bool Input::checkAxisInput(InputType input, int controller_index) const
{
	bool success = false;

	switch (input)
	{
	case InputType::LEFT:
		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) < -30000)
		{
			success = true;
		}
		break;

	case InputType::RIGHT:
		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTX) > 30000)
		{
			success = true;
		}
		break;

	case InputType::UP:
		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) < -30000)
		{
			success = true;
		}
		break;

	case InputType::DOWN:
		if (SDL_GameControllerGetAxis(connected_controllers_[controller_index], SDL_CONTROLLER_AXIS_LEFTY) > 30000)
		{
			success = true;
		}
		break;

	default:
		break;
	}

	return success;
}