/*
 * Copyright (C) 2023  Christopher J. Howard
 *
 * This file is part of Antkeeper source code.
 *
 * Antkeeper source code is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * Antkeeper source code is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Antkeeper source code.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <engine/app/sdl/sdl-input-manager.hpp>
#include <engine/input/application-events.hpp>
#include <engine/input/input-update-event.hpp>
#include <engine/debug/log.hpp>
#include <engine/math/map.hpp>
#include <SDL2/SDL.h>
#include <stdexcept>

namespace app {

sdl_input_manager::sdl_input_manager()
{
	// Init SDL joystick and controller subsystems
	debug::log_trace("Initializing SDL joystick and controller subsystems...");
	if (SDL_InitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER) != 0)
	{
		debug::log_error("Failed to initialize SDL joystick and controller subsytems: {}", SDL_GetError());
		throw std::runtime_error("Failed to initialize SDL joystick and controller subsytems");
	}
	else
	{
		debug::log_trace("Initialized SDL joystick and controller subsystems");
	}
	
	// Register keyboard and mouse
	register_keyboard(m_keyboard);
	register_mouse(m_mouse);
	
	// Generate keyboard and mouse device connected events
	m_keyboard.connect();
	m_mouse.connect();
}

sdl_input_manager::~sdl_input_manager()
{
	// Quit SDL joystick and controller subsystems
	debug::log_trace("Quitting SDL joystick and controller subsystems...");
	SDL_QuitSubSystem(SDL_INIT_JOYSTICK | SDL_INIT_GAMECONTROLLER);
	debug::log_trace("Quit SDL joystick and controller subsystems...");
}

void sdl_input_manager::update()
{
	// Active modifier keys
	std::uint16_t sdl_key_mod = KMOD_NONE;
	std::uint16_t modifier_keys = input::modifier_key::none;
	
	// Gather SDL events from event queue
	SDL_PumpEvents();
	
	// Handle OS events
	for (;;)
	{
		// Get next display or window event
		SDL_Event event;
		const int status = SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_FIRSTEVENT, SDL_LOCALECHANGED);
		
		if (!status)
		{
			break;
		}
		else if (status < 0)
		{
			debug::log_error("Failed to peep SDL events: {}", SDL_GetError());
			throw std::runtime_error("Failed to peep SDL events");
		}
		
		switch (event.type)
		{
			case SDL_QUIT:
				debug::log_debug("Application quit requested");
				this->m_event_dispatcher.dispatch<input::application_quit_event>({});
				break;
			
			default:
				break;
		}
	}
	
	// Handle keyboard, mouse, and gamepad events
	for (;;)
	{
		// Get next display or window event
		SDL_Event event;
		const int status = SDL_PeepEvents(&event, 1, SDL_GETEVENT, SDL_KEYDOWN, SDL_LASTEVENT);
		
		if (!status)
		{
			break;
		}
		else if (status < 0)
		{
			debug::log_error("Failed to peep SDL events: {}", SDL_GetError());
			throw std::runtime_error("Failed to peep SDL events");
		}
		
		switch (event.type)
		{
			[[likely]] case SDL_MOUSEMOTION:
			{
				m_mouse.move({event.motion.x, event.motion.y}, {event.motion.xrel, event.motion.yrel});
				break;
			}
			
			[[likely]] case SDL_KEYDOWN:
			case SDL_KEYUP:
			{
				// Get scancode of key
				const input::scancode scancode = static_cast<input::scancode>(event.key.keysym.scancode);
				
				// Rebuild modifier keys bit mask
				if (sdl_key_mod != event.key.keysym.mod)
				{
					sdl_key_mod = event.key.keysym.mod;
					
					modifier_keys = input::modifier_key::none;
					if (sdl_key_mod & KMOD_LSHIFT)
						modifier_keys |= input::modifier_key::left_shift;
					if (sdl_key_mod & KMOD_RSHIFT)
						modifier_keys |= input::modifier_key::right_shift;
					if (sdl_key_mod & KMOD_LCTRL)
						modifier_keys |= input::modifier_key::left_ctrl;
					if (sdl_key_mod & KMOD_RCTRL)
						modifier_keys |= input::modifier_key::right_ctrl;
					if (sdl_key_mod & KMOD_LALT)
						modifier_keys |= input::modifier_key::left_alt;
					if (sdl_key_mod & KMOD_RALT)
						modifier_keys |= input::modifier_key::right_alt;
					if (sdl_key_mod & KMOD_LGUI)
						modifier_keys |= input::modifier_key::left_gui;
					if (sdl_key_mod & KMOD_RGUI)
						modifier_keys |= input::modifier_key::right_gui;
					if (sdl_key_mod & KMOD_NUM)
						modifier_keys |= input::modifier_key::num_lock;
					if (sdl_key_mod & KMOD_CAPS)
						modifier_keys |= input::modifier_key::caps_lock;
					if (sdl_key_mod & KMOD_SCROLL)
						modifier_keys |= input::modifier_key::scroll_lock;
					if (sdl_key_mod & KMOD_MODE)
						modifier_keys |= input::modifier_key::alt_gr;
				}
				
				if (event.type == SDL_KEYDOWN)
				{
					m_keyboard.press(scancode, modifier_keys, (event.key.repeat > 0));
				}
				else
				{
					m_keyboard.release(scancode, modifier_keys);
				}
				
				break;
			}
			
			case SDL_MOUSEWHEEL:
			{
				const float flip = (event.wheel.direction == SDL_MOUSEWHEEL_FLIPPED) ? -1.0f : 1.0f;
				m_mouse.scroll({event.wheel.preciseX * flip, event.wheel.preciseY * flip});
				break;
			}
			
			case SDL_MOUSEBUTTONDOWN:
			{
				m_mouse.press(static_cast<input::mouse_button>(event.button.button));
				break;
			}
			
			case SDL_MOUSEBUTTONUP:
			{
				m_mouse.release(static_cast<input::mouse_button>(event.button.button));
				break;
			}
			
			[[likely]] case SDL_CONTROLLERAXISMOTION:
			{
				if (event.caxis.axis != SDL_CONTROLLER_AXIS_INVALID)
				{
					if (auto it = m_gamepad_map.find(event.cdevice.which); it != m_gamepad_map.end())
					{
						// Map axis position onto `[-1, 1]`.
						const float position = math::map
						(
							static_cast<float>(event.caxis.value),
							static_cast<float>(std::numeric_limits<decltype(event.caxis.value)>::min()),
							static_cast<float>(std::numeric_limits<decltype(event.caxis.value)>::max()),
							-1.0f,
							1.0f
						);
						
						// Generate gamepad axis moved event
						it->second->move(static_cast<input::gamepad_axis>(event.caxis.axis), position);
					}
				}
				break;
			}
			
			case SDL_CONTROLLERBUTTONDOWN:
			{
				if (event.cbutton.button != SDL_CONTROLLER_BUTTON_INVALID)
				{
					if (auto it = m_gamepad_map.find(event.cdevice.which); it != m_gamepad_map.end())
					{
						it->second->press(static_cast<input::gamepad_button>(event.cbutton.button));
					}
				}
				break;
			}
			
			case SDL_CONTROLLERBUTTONUP:
			{
				if (event.cbutton.button != SDL_CONTROLLER_BUTTON_INVALID)
				{
					if (auto it = m_gamepad_map.find(event.cdevice.which); it != m_gamepad_map.end())
					{
						it->second->release(static_cast<input::gamepad_button>(event.cbutton.button));
					}
				}
				break;
			}
			
			[[unlikely]] case SDL_CONTROLLERDEVICEADDED:
			{
				if (SDL_IsGameController(event.cdevice.which))
				{
					SDL_GameController* sdl_controller = SDL_GameControllerOpen(event.cdevice.which);
					if (sdl_controller)
					{
						// Get gamepad name
						const char* controller_name = SDL_GameControllerNameForIndex(event.cdevice.which);
						if (!controller_name)
						{
							controller_name = "";
						}
						
						if (auto it = m_gamepad_map.find(event.cdevice.which); it != m_gamepad_map.end())
						{
							// Gamepad reconnected
							debug::log_info("Reconnected gamepad {}", event.cdevice.which);
							it->second->connect();
						}
						else
						{
							// Get gamepad GUID
							SDL_Joystick* sdl_joystick = SDL_GameControllerGetJoystick(sdl_controller);
							SDL_JoystickGUID sdl_guid = SDL_JoystickGetGUID(sdl_joystick);
							
							// Copy into UUID struct
							::uuid gamepad_uuid;
							std::memcpy(gamepad_uuid.data.data(), sdl_guid.data, gamepad_uuid.data.size());
							
							debug::log_info("Connected gamepad {}; name: \"{}\"; UUID: {}", event.cdevice.which, controller_name, gamepad_uuid.string());
							
							// Allocate gamepad
							auto& gamepad = m_gamepad_map[event.cdevice.which];
							gamepad = std::make_unique<input::gamepad>();						
							gamepad->set_uuid(gamepad_uuid);
							
							// Register gamepad
							register_device(*gamepad);
							
							// Generate gamepad connected event
							gamepad->connect();
						}
					}
					else
					{
						debug::log_error("Failed to connect gamepad {}: {}", event.cdevice.which, SDL_GetError());
						SDL_ClearError();
					}
				}

				break;
			}
			
			[[unlikely]] case SDL_CONTROLLERDEVICEREMOVED:
			{
				SDL_GameController* sdl_controller = SDL_GameControllerFromInstanceID(event.cdevice.which);
				
				if (sdl_controller)
				{
					SDL_GameControllerClose(sdl_controller);
					if (auto it = m_gamepad_map.find(event.cdevice.which); it != m_gamepad_map.end())
					{
						it->second->disconnect();
					}
					
					debug::log_info("Disconnected gamepad {}", event.cdevice.which);
				}
				
				break;
			}
			
			default:
				break;
		}
	}
	
	// Dispatch input update event
	this->m_event_dispatcher.dispatch<input::update_event>({});
}

void sdl_input_manager::set_cursor_visible(bool visible)
{
	if (SDL_ShowCursor((visible) ? SDL_ENABLE : SDL_DISABLE) < 0)
	{
		debug::log_error("Failed to set cursor visibility: \"{}\"", SDL_GetError());
		SDL_ClearError();
	}
}

void sdl_input_manager::set_relative_mouse_mode(bool enabled)
{
	if (SDL_SetRelativeMouseMode((enabled) ? SDL_TRUE : SDL_FALSE) < 0)
	{
		debug::log_error("Failed to set relative mouse mode: \"{}\"", SDL_GetError());
		SDL_ClearError();
	}
}

} // namespace app