#pragma once

#include <SDL3/SDL_gamepad.h>  // Para SDL_GamepadButton, SDL_Gamepad
#include <SDL3/SDL_joystick.h> // Para SDL_Joystick, SDL_JoystickID
#include <SDL3/SDL_scancode.h> // Para SDL_Scancode
#include <SDL3/SDL_stdinc.h>   // Para Uint8
#include <string>			   // Para string
#include <vector>			   // Para vector

/*
connectedControllers es un vector donde están todos los mandos encontrados [0 .. n]
checkInput requiere de un índice para comprobar las pulsaciones de un controlador en concreto [0 .. n]
device contiene el tipo de dispositivo a comprobar:
	InputDeviceToUse::KEYBOARD solo mirará el teclado
	InputDeviceToUse::CONTROLLER solo mirará el controlador especificado (Si no se especifica, el primero)
	InputDeviceToUse::ANY mirará tanto el teclado como el PRIMER controlador
*/

// Acciones de entrada posibles en el juego
enum class InputAction : int
{
	// Inputs de movimiento
	UP,
	DOWN,
	LEFT,
	RIGHT,

	// Inputs personalizados
	FIRE_LEFT,
	FIRE_CENTER,
	FIRE_RIGHT,
	START,

	// Inputs de control
	EXIT,
	PAUSE,
	SERVICE,
	WINDOW_FULLSCREEN,
	WINDOW_INC_SIZE,
	WINDOW_DEC_SIZE,
	TOGGLE_VIDEO_SHADERS,
	TOGGLE_VIDEO_INTEGER_SCALE,
	TOGGLE_VIDEO_VSYNC,
	RESET,
	TOGGLE_AUDIO,
	CHANGE_LANG,
	SHOW_INFO,
	CONFIG,
	SWAP_CONTROLLERS,
	TOGGLE_AUTO_FIRE,

	// Input obligatorio
	NONE,
	SIZE,
};

constexpr bool INPUT_ALLOW_REPEAT = true;
constexpr bool INPUT_DO_NOT_ALLOW_REPEAT = false;

// Tipos de dispositivos de entrada
enum class InputDeviceToUse : int
{
	KEYBOARD = 0,
	CONTROLLER = 1,
	ANY = 2,
};

// Clase Input: gestiona la entrada de teclado y mandos (singleton)
class Input
{
public:
	// [SINGLETON] Crearemos el objeto con esta función estática
	static void init(const std::string &game_controller_db_path);

	// [SINGLETON] Destruiremos el objeto con esta función estática
	static void destroy();

	// [SINGLETON] Con este método obtenemos el objeto y podemos trabajar con él
	static Input *get();

	// Asigna inputs a teclas
	void bindKey(InputAction input, SDL_Scancode code);

	// Asigna inputs a botones del mando
	void bindGameControllerButton(int controller_index, InputAction input, SDL_GamepadButton button);
	void bindGameControllerButton(int controller_index, InputAction inputTarget, InputAction inputSource);

	// Comprueba si un input está activo
	bool checkInput(InputAction input, bool repeat = true, InputDeviceToUse device = InputDeviceToUse::ANY, int controller_index = 0);

	// Comprueba si hay al menos un input activo
	bool checkAnyInput(InputDeviceToUse device = InputDeviceToUse::ANY, int controller_index = 0);

	// Comprueba si hay algún botón pulsado
	int checkAnyButtonPressed(bool repeat = INPUT_DO_NOT_ALLOW_REPEAT);

	// Busca si hay mandos conectados
	bool discoverGameControllers();

	// Comprueba si hay algún mando conectado
	bool gameControllerFound();

	// Obtiene el número de mandos conectados
	int getNumControllers() const;

	// Obtiene el nombre de un mando de juego
	std::string getControllerName(int controller_index) const;

	// Obtiene el índice del controlador a partir de un event.id
	int getJoyIndex(SDL_JoystickID id) const;

	// Muestra por consola los controles asignados
	void printBindings(InputDeviceToUse device = InputDeviceToUse::KEYBOARD, int controller_index = 0) const;

	// Obtiene el SDL_GamepadButton asignado a un input
	SDL_GamepadButton getControllerBinding(int controller_index, InputAction input) const;

	// Convierte un InputAction a std::string
	std::string to_string(InputAction input) const;

	// Convierte un std::string a InputAction
	InputAction to_inputs_e(const std::string &name) const;

	// Obtiene el índice a partir del nombre del mando
	int getIndexByName(const std::string &name) const;

private:
	// [SINGLETON] Objeto privado
	static Input *input_;

	// Estructura para asociar teclas a acciones
	struct KeyBindings
	{
		Uint8 scancode; // Scancode asociado
		bool active;	// Indica si está activo

		KeyBindings(Uint8 sc = 0, bool act = false)
			: scancode(sc), active(act) {}
	};

	// Estructura para asociar botones de mando a acciones
	struct ControllerBindings
	{
		SDL_GamepadButton button; // GameControllerButton asociado
		bool active;			  // Indica si está activo
		bool axis_active;		  // Estado del eje

		ControllerBindings(SDL_GamepadButton btn = SDL_GAMEPAD_BUTTON_INVALID, bool act = false, bool axis_act = false)
			: button(btn), active(act), axis_active(axis_act) {}
	};

	// Variables internas
	std::vector<SDL_Gamepad *> connected_controllers_;				   // Vector con todos los mandos conectados
	std::vector<SDL_Joystick *> joysticks_;							   // Vector con todos los joysticks conectados
	std::vector<KeyBindings> key_bindings_;							   // Vector con las teclas asociadas a los inputs predefinidos
	std::vector<std::vector<ControllerBindings>> controller_bindings_; // Vector con los botones asociados a los inputs predefinidos para cada mando
	std::vector<std::string> controller_names_;						   // Vector con los nombres de los mandos
	std::vector<InputAction> button_inputs_;						   // Inputs asignados al jugador y a botones, excluyendo direcciones
	int num_joysticks_ = 0;											   // Número de joysticks conectados
	int num_gamepads_ = 0;											   // Número de mandos conectados
	std::string game_controller_db_path_;							   // Ruta al archivo gamecontrollerdb.txt

	void initSDL(); // Inicializa SDL para la gestión de mandos

	// Comprueba el eje del mando
	bool checkAxisInput(InputAction input, int controller_index, bool repeat);

	// Constructor privado
	explicit Input(const std::string &game_controller_db_path);

	// Destructor
	~Input() = default;
};