#define GLFW_EXPOSE_NATIVE_X11
#include <GLFW/glfw3.h>
#include <GLFW/glfw3native.h>
#include <surface/system.hpp>

namespace lt::surface {

void handle_event(GLFWwindow *window, const SurfaceComponent::Event &event)
{
	auto &callbacks = *static_cast<std::vector<SurfaceComponent::EventCallback> *>(
	    glfwGetWindowUserPointer(window)
	);

	for (auto &callback : callbacks)
	{
		if (callback(event))
		{
			return;
		}
	}
}

void bind_glfw_events(GLFWwindow *handle)
{
	glfwSetWindowPosCallback(handle, [](GLFWwindow *window, int xpos, int ypos) {
		handle_event(window, MovedEvent { xpos, ypos });
	});

	glfwSetWindowSizeCallback(handle, [](GLFWwindow *window, int width, int height) {
		handle_event(
		    window,
		    ResizedEvent { static_cast<uint32_t>(width), static_cast<uint32_t>(height) }
		);
	});

	glfwSetWindowCloseCallback(handle, [](GLFWwindow *window) {
		handle_event(window, ClosedEvent {});
	});

	glfwSetWindowFocusCallback(handle, [](GLFWwindow *window, int focus) {
		if (focus == GLFW_TRUE)
		{
			handle_event(window, GainFocusEvent {});
		}
		else
		{
			handle_event(window, LostFocusEvent {});
		}
	});

	glfwSetCursorPosCallback(handle, [](GLFWwindow *window, double xpos, double ypos) {
		handle_event(
		    window,
		    MouseMovedEvent { static_cast<float>(xpos), static_cast<float>(ypos) }
		);
	});

	glfwSetMouseButtonCallback(
	    handle,
	    [](GLFWwindow *window, int button, int action, int /*mods*/) {
		    if (action == GLFW_PRESS)
		    {
			    handle_event(window, ButtonPressedEvent { button });
		    }
		    else if (action == GLFW_RELEASE)
		    {
			    handle_event(window, ButtonReleasedEvent { button });
		    }
	    }
	);

	glfwSetScrollCallback(handle, [](GLFWwindow *window, double /*xoffset*/, double yoffset) {
		handle_event(window, WheelScrolledEvent { static_cast<float>(yoffset) });
	});

	glfwSetKeyCallback(
	    handle,
	    [](GLFWwindow *window, int key, int /*scancode*/, int action, int /*mods*/) {
		    if (action == GLFW_PRESS)
		    {
			    handle_event(window, KeyPressedEvent { key });
		    }
		    else if (action == GLFW_RELEASE)
		    {
			    handle_event(window, KeyReleasedEvent { key });
		    }
	    }
	);

	glfwSetCharCallback(handle, [](GLFWwindow *window, unsigned int character) {
		handle_event(window, KeySetCharEvent { character });
	});
}

System::System(Ref<ecs::Registry> registry): m_registry(std::move(registry))
{
	ensure(m_registry, "Failed to initialize surface system: null registry");
	ensure(
	    m_registry->view<SurfaceComponent>().size() == 0,
	    "Failed to initialize surface system: registry has surface component(s)"
	);

	m_registry->get_entt_registry()
	    .on_construct<SurfaceComponent>()
	    .connect<&System::on_surface_construct>(this);

	m_registry->get_entt_registry()
	    .on_update<SurfaceComponent>()
	    .connect<&System::on_surface_update>(this);

	m_registry->get_entt_registry()
	    .on_destroy<SurfaceComponent>()
	    .connect<&System::on_surface_destroy>(this);
}

System::~System()
{
	m_registry->get_entt_registry()
	    .on_construct<SurfaceComponent>()
	    .disconnect<&System::on_surface_construct>(this);

	m_registry->get_entt_registry()
	    .on_update<SurfaceComponent>()
	    .connect<&System::on_surface_update>(this);

	m_registry->get_entt_registry()
	    .on_destroy<SurfaceComponent>()
	    .disconnect<&System::on_surface_destroy>(this);


	m_registry->view<SurfaceComponent>().each([&](const entt::entity entity, SurfaceComponent &) {
		std::cout << "REMOVED SURFACE COMPONENT ON DESTRUCTION" << std::endl;
		m_registry->get_entt_registry().remove<SurfaceComponent>(entity);
	});

	glfwTerminate();
}

void System::on_surface_construct(entt::registry &registry, entt::entity entity)
{
	ensure(glfwInit(), "Failed to initialize 'glfw'");

	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 5);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
	// glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);

	auto &surface = registry.get<SurfaceComponent>(entity);
	auto [width, height] = surface.get_size();

	surface.m_glfw_handle = glfwCreateWindow(
	    static_cast<int32_t>(width),
	    static_cast<int32_t>(height),
	    surface.get_title().begin(),
	    nullptr,
	    nullptr
	);
	ensure(surface.m_glfw_handle, "Failed to create 'GLFWwindow'");

	glfwSetWindowUserPointer(surface.m_glfw_handle, &surface.m_event_callbacks);
	surface.m_native_handle = glfwGetX11Window(surface.m_glfw_handle);
	bind_glfw_events(surface.m_glfw_handle);
}

void System::on_surface_update(entt::registry &registry, entt::entity entity)
{
	auto &surface = registry.get<SurfaceComponent>(entity);
	glfwSetWindowUserPointer(surface.m_glfw_handle, &surface.m_event_callbacks);
}

void System::on_surface_destroy(entt::registry &registry, entt::entity entity)
{
	auto &surface = registry.get<SurfaceComponent>(entity);
	glfwDestroyWindow(surface.m_glfw_handle);
}

void System::set_title(ecs::Entity entity, std::string_view new_title)
{
	auto &surface = entity.get_component<SurfaceComponent>();

	surface.m_title = new_title;
	glfwSetWindowTitle(surface.m_glfw_handle, surface.m_title.begin());
}

auto System::tick() -> bool
{
	glfwPollEvents();
	return false;
}

void System::set_size(ecs::Entity surface_entity, const math::uvec2 &new_size)
{
	auto &surface = surface_entity.get_component<SurfaceComponent>();
	surface.m_size = new_size;

	glfwSetWindowSize(
	    surface.m_glfw_handle,
	    static_cast<int>(new_size.x),
	    static_cast<int>(new_size.y)
	);
}

void System::set_v_sync(ecs::Entity surface_entity, bool vsync)
{
	auto &surface = surface_entity.get_component<SurfaceComponent>();
	surface.m_vsync = vsync;

	glfwSwapInterval(vsync);
}

void System::set_visibility(ecs::Entity surface_entity, bool visible)
{
	auto &surface = surface_entity.get_component<SurfaceComponent>();
	surface.m_visible = visible;

	if (visible)
	{
		glfwShowWindow(surface.m_glfw_handle);
	}
	else
	{
		glfwHideWindow(surface.m_glfw_handle);
	}
}

void System::add_event_listener(
    ecs::Entity surface_entity,
    SurfaceComponent::EventCallback callback
)
{
	auto &surface = surface_entity.get_component<SurfaceComponent>();
	surface.m_event_callbacks.emplace_back(std::move(callback));
}

} // namespace lt::surface

namespace lt {

} // namespace lt