#include "App.hpp"

#include <cassert>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <poll.h>
#include <pthread.h>
#include <signal.h>
#include <span>
#include <sys/mman.h>
#include <sys/signalfd.h>
#include <thread>
#include <unistd.h>
#include <unordered_set>
#include <vector>

#include <GLES3/gl3.h>
#include <fontconfig/fontconfig.h>
#include <glib.h>
#include <raylib.h>
#include <rlgl.h>
#include <xkbcommon/xkbcommon.h>

#define namespace namespace_
#include "wlr-layer-shell-unstable-v1-client-protocol.h"
#undef namespace

#include "blur-client-protocol.h"
#include "ext-background-effect-v1-client-protocol.h"

auto TypingBuffer::push_utf8(char const *s) -> void
{
	for (unsigned char const *p = reinterpret_cast<unsigned char const *>(s);
	    *p;) {
		u32 cp = 0;
		int len = 0;
		if (*p < 0x80) {
			cp = *p++;
			len = 1;
		} else if ((*p & 0xE0) == 0xC0) {
			cp = *p++ & 0x1F;
			len = 2;
		} else if ((*p & 0xF0) == 0xE0) {
			cp = *p++ & 0x0F;
			len = 3;
		} else {
			cp = *p++ & 0x07;
			len = 4;
		}
		for (int i = 1; i < len; i++)
			cp = (cp << 6) | ((*p++) & 0x3F);
		push_back(cp);
	}
}

App::App()
{
	init_wayland();
	init_egl();
	init_signal();
	init_theme_portal();
}

App::~App()
{
	if (m_sfd != -1)
		close(m_sfd);

	destroy_layer_surface();

	if (m_gl.edpy != EGL_NO_DISPLAY) {
		if (m_gl.ectx != EGL_NO_CONTEXT)
			eglDestroyContext(m_gl.edpy, m_gl.ectx);
		eglTerminate(m_gl.edpy);
	}

	if (m_kbd.xkb_state_v)
		xkb_state_unref(m_kbd.xkb_state_v);
	if (m_kbd.xkb_keymap_v)
		xkb_keymap_unref(m_kbd.xkb_keymap_v);
	if (m_kbd.xkb_ctx_v)
		xkb_context_unref(m_kbd.xkb_ctx_v);
	if (m_wayland.kbd)
		wl_keyboard_destroy(m_wayland.kbd);
	if (m_wayland.seat)
		wl_seat_destroy(m_wayland.seat);
	if (m_wayland.compositor)
		wl_compositor_destroy(m_wayland.compositor);
	if (m_wayland.registry)
		wl_registry_destroy(m_wayland.registry);
	if (m_wayland.display)
		wl_display_disconnect(m_wayland.display);

	if (m_xdp.settings)
		g_object_unref(m_xdp.settings);
	if (m_xdp.portal)
		g_object_unref(m_xdp.portal);
}

auto App::run() -> void
{
	SetWindowSize(m_win_w, m_win_h);
	while (m_running) {
		pump_events();
		tick();
		std::this_thread::sleep_for(std::chrono::milliseconds(16));
	}
}

auto App::set_visible(bool visible) -> void
{
	if (visible == m_visible)
		return;

	if (visible) {
		create_layer_surface();
		ensure_egl_surface();
	} else {
		destroy_layer_surface();
	}

	if (m_wayland.display)
		wl_display_flush(m_wayland.display);
}

auto App::init_wayland() -> void
{
	m_wayland.display = wl_display_connect(nullptr);
	if (!m_wayland.display) {
		std::fprintf(stderr, "failed to connect to Wayland display\n");
		std::exit(EXIT_FAILURE);
	}

	static wl_keyboard_listener keyboard_listener {};
	{
		auto kb_keymap = [](void *data, wl_keyboard *, u32 format, i32 fd,
		                     u32 size) -> void {
			auto *app = static_cast<App *>(data);
			if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
				close(fd);
				return;
			}
			void *map = mmap(nullptr, size, PROT_READ, MAP_PRIVATE, fd, 0);
			if (map == MAP_FAILED) {
				close(fd);
				return;
			}
			if (app->m_kbd.xkb_keymap_v)
				xkb_keymap_unref(app->m_kbd.xkb_keymap_v);
			if (app->m_kbd.xkb_state_v) {
				xkb_state_unref(app->m_kbd.xkb_state_v);
				app->m_kbd.xkb_state_v = nullptr;
			}
			app->m_kbd.xkb_keymap_v = xkb_keymap_new_from_string(
			    app->m_kbd.xkb_ctx_v, static_cast<char const *>(map),
			    XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
			app->m_kbd.xkb_state_v = app->m_kbd.xkb_keymap_v
			    ? xkb_state_new(app->m_kbd.xkb_keymap_v)
			    : nullptr;
			munmap(map, size);
			close(fd);
		};

		auto kb_enter = [](void *, wl_keyboard *, u32, wl_surface *,
		                    wl_array *) -> void { };
		auto kb_leave
		    = [](void *data, wl_keyboard *, u32, wl_surface *) -> void {
			static_cast<App *>(data)->m_kbd.held.clear();
		};

		auto kb_key = [](void *data, wl_keyboard *, u32, u32, u32 key,
		                  u32 state) -> void {
			auto *app = static_cast<App *>(data);
			if (!app->m_kbd.xkb_state_v)
				return;

			xkb_keycode_t kc = key + 8;

			if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
				app->m_kbd.held.insert(key);

				xkb_state_update_key(app->m_kbd.xkb_state_v, kc, XKB_KEY_DOWN);
				xkb_keysym_t sym
				    = xkb_state_key_get_one_sym(app->m_kbd.xkb_state_v, kc);
				app->m_kbd.pressed_syms.insert(sym);

				bool ctrl = app->m_kbd.mod_active("Control");
				bool alt = app->m_kbd.mod_active("Mod1");
				bool meta = app->m_kbd.mod_active("Mod4");

				bool handled = false;
				switch (sym) {
				case XKB_KEY_Left:
					app->m_kbd.typing.push_back(1);
					handled = true;
					break;
				case XKB_KEY_Down:
					app->m_kbd.typing.push_back(2);
					handled = true;
					break;
				case XKB_KEY_Up:
					app->m_kbd.typing.push_back(3);
					handled = true;
					break;
				case XKB_KEY_Right:
					app->m_kbd.typing.push_back(4);
					handled = true;
					break;
				case XKB_KEY_BackSpace:
					app->m_kbd.typing.push_back(8);
					handled = true;
					break;
				case XKB_KEY_Delete:
				case XKB_KEY_KP_Delete:
					app->m_kbd.typing.push_back(0x7F);
					handled = true;
					break;
				case XKB_KEY_Return:
				case XKB_KEY_KP_Enter:
					app->m_kbd.typing.push_back('\n');
					handled = true;
					break;
				case XKB_KEY_w:
				case XKB_KEY_W:
					if (ctrl) {
						app->m_kbd.typing.push_back(8);
						handled = true;
					}
					break;
				default:
					break;
				}

				if (!handled && !(ctrl || alt || meta)) {
					u32 cp = xkb_keysym_to_utf32(sym);
					if (cp >= 0x20) {
						char buf[8];
						int n = xkb_keysym_to_utf8(sym, buf, sizeof(buf));
						if (n > 0)
							app->m_kbd.typing.push_utf8(buf);
					}
				}
			} else {
				xkb_keysym_t sym
				    = xkb_state_key_get_one_sym(app->m_kbd.xkb_state_v, kc);
				app->m_kbd.released_syms.insert(sym);

				app->m_kbd.held.erase(key);
				xkb_state_update_key(app->m_kbd.xkb_state_v, kc, XKB_KEY_UP);
			}
		};

		auto kb_mods = [](void *data, wl_keyboard *, u32, u32 depressed,
		                   u32 latched, u32 locked, u32 group) -> void {
			auto *app = static_cast<App *>(data);
			if (!app->m_kbd.xkb_state_v)
				return;
			xkb_state_update_mask(app->m_kbd.xkb_state_v, depressed, latched,
			    locked, 0, 0, group);
		};

		auto kb_repeat_info = [](void *, wl_keyboard *, i32, i32) -> void { };

		keyboard_listener = { kb_keymap, kb_enter, kb_leave, kb_key, kb_mods,
			kb_repeat_info };
	}

	auto handle_registry_global
	    = [](void *data, wl_registry *registry, u32 name, char const *interface,
	          u32 version) -> void {
		auto *app = static_cast<App *>(data);
		if (std::strcmp(interface, wl_compositor_interface.name) == 0) {
			app->m_wayland.compositor = static_cast<wl_compositor *>(
			    wl_registry_bind(registry, name, &wl_compositor_interface, 4));
		} else if (std::strcmp(interface, wl_seat_interface.name) == 0) {
			app->m_wayland.seat = static_cast<wl_seat *>(
			    wl_registry_bind(registry, name, &wl_seat_interface, 9));
			static struct wl_seat_listener const seat_listener = {
				.capabilities =
				    [](void *data, struct wl_seat *seat, u32 caps) {
				        auto *app = static_cast<App *>(data);
				        if (caps & WL_SEAT_CAPABILITY_KEYBOARD) {
					        app->m_wayland.kbd = wl_seat_get_keyboard(seat);
					        wl_keyboard_add_listener(
					            app->m_wayland.kbd, &keyboard_listener, data);
				        }
				    },
				.name = [](void *, struct wl_seat *, char const *) {},
			};
			wl_seat_add_listener(app->m_wayland.seat, &seat_listener, data);
		} else if (std::strcmp(interface, zwlr_layer_shell_v1_interface.name)
		    == 0) {
			app->m_wayland.layer_shell = static_cast<zwlr_layer_shell_v1 *>(
			    wl_registry_bind(registry, name, &zwlr_layer_shell_v1_interface,
			        version >= 4 ? 4 : version));
		} else if (std::strcmp(interface,
		               ext_background_effect_manager_v1_interface.name)
		    == 0) {
			app->m_wayland.mgr
			    = static_cast<ext_background_effect_manager_v1 *>(
			        wl_registry_bind(registry, name,
			            &ext_background_effect_manager_v1_interface, 1));
		} else if (std::strcmp(interface, "org_kde_kwin_blur_manager") == 0) {
			app->m_wayland.kde_blur_mgr
			    = static_cast<org_kde_kwin_blur_manager *>(wl_registry_bind(
			        registry, name, &org_kde_kwin_blur_manager_interface, 1));
		}
	};

	static wl_registry_listener const registry_listener {
		.global = handle_registry_global,
		.global_remove = [](void *, wl_registry *, u32) { },
	};

	m_wayland.registry = wl_display_get_registry(m_wayland.display);
	wl_registry_add_listener(m_wayland.registry, &registry_listener, this);

	m_kbd.xkb_ctx_v = xkb_context_new(XKB_CONTEXT_NO_FLAGS);

	wl_display_roundtrip(m_wayland.display);

	create_layer_surface();
}

auto App::init_egl() -> void
{
	m_gl.edpy = eglGetDisplay(
	    reinterpret_cast<EGLNativeDisplayType>(m_wayland.display));
	eglInitialize(m_gl.edpy, nullptr, nullptr);

	EGLint const cfgAttribs[] { EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
		EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_RED_SIZE, 8,
		EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_ALPHA_SIZE, 8, EGL_NONE };
	EGLint n = 0;
	eglChooseConfig(m_gl.edpy, cfgAttribs, &m_gl.ecfg, 1, &n);

	EGLint const ctxAttribs[] = { EGL_CONTEXT_MAJOR_VERSION, 2, EGL_NONE };
	m_gl.ectx
	    = eglCreateContext(m_gl.edpy, m_gl.ecfg, EGL_NO_CONTEXT, ctxAttribs);

	ensure_egl_surface();

	InitWindow(m_win_w, m_win_h, "");

	m_tr = std::make_shared<TextRenderer>();
	m_gui = std::make_shared<ImGui>(m_tr);
	auto const font = find_font_path();
	assert(font && "Could not find font");
	std::vector<std::filesystem::path> fallback_paths;
	std::unordered_set<std::string> seen_paths;
	auto const primary_path_str = font->string();

	constexpr char const *fallback_candidates[] = {
		"Noto Sans CJK JP:style=Regular",
		"Noto Sans CJK SC:style=Regular",
		"Noto Sans CJK KR:style=Regular",
		"Noto Sans CJK TC:style=Regular",
		"sans-serif:lang=ja",
		"sans-serif:lang=ko",
		"sans-serif:lang=zh-cn",
		"sans-serif:lang=zh-tw",
		"sans-serif:lang=zh-hk",
	};
	for (auto const *name : fallback_candidates) {
		if (auto fallback = find_font_path(name)) {
			auto const path_str = fallback->string();
			if (path_str == primary_path_str)
				continue;
			if (!seen_paths.emplace(path_str).second)
				continue;
			fallback_paths.push_back(*fallback);
		}
	}
	if (fallback_paths.empty()) {
		TraceLog(LOG_WARNING,
		    "No fallback fonts found; some glyphs may render as missing");
	}
	auto const font_handle = m_tr->load_font(*font, std::span(fallback_paths));
	assert(font_handle && "Could not load font");
	m_font = *font_handle;
	m_gui->set_font(m_font);
}

auto App::init_signal() -> void
{
	sigset_t mask;
	sigemptyset(&mask);
	sigaddset(&mask, SIGUSR1);

	if (pthread_sigmask(SIG_BLOCK, &mask, nullptr) != 0) {
		std::perror("pthread_sigmask");
		std::exit(EXIT_FAILURE);
	}

	m_sfd = signalfd(-1, &mask, SFD_NONBLOCK | SFD_CLOEXEC);
	if (m_sfd == -1) {
		std::perror("signalfd");
		std::exit(EXIT_FAILURE);
	}
}

void App::on_settings_changed(XdpSettings * /*self*/, char const *ns,
    char const *key, GVariant * /*value*/, gpointer data)
{
	auto *app = static_cast<App *>(data);
	if (g_strcmp0(ns, "org.freedesktop.appearance") == 0
	    && g_strcmp0(key, "color-scheme") == 0) {
		guint v = xdp_settings_read_uint(app->m_xdp.settings,
		    "org.freedesktop.appearance", "color-scheme", NULL, NULL);

		if (v == 1)
			app->m_active_theme = Theme::Dark;
		else
			app->m_active_theme = Theme::Light;
	}
}

auto App::init_theme_portal() -> void
{
	m_xdp.portal = xdp_portal_new();
	m_xdp.settings = xdp_portal_get_settings(m_xdp.portal);

	guint v = xdp_settings_read_uint(m_xdp.settings,
	    "org.freedesktop.appearance", "color-scheme", NULL, NULL);
	if (v == 1)
		m_active_theme = Theme::Dark;
	else
		m_active_theme = Theme::Light;

	g_signal_connect(
	    m_xdp.settings, "changed", G_CALLBACK(on_settings_changed), this);
}

auto App::create_layer_surface() -> void
{
	if (m_wayland.layer_surface)
		return;

	if (!m_wayland.compositor || !m_wayland.layer_shell)
		return;

	m_wayland.surface = wl_compositor_create_surface(m_wayland.compositor);

	if (m_wayland.mgr) {
		m_wayland.eff = ext_background_effect_manager_v1_get_background_effect(
		    m_wayland.mgr, m_wayland.surface);
	}
	if (m_wayland.kde_blur_mgr) {
		m_wayland.kde_blur = org_kde_kwin_blur_manager_create(
		    m_wayland.kde_blur_mgr, m_wayland.surface);
	}

	m_wayland.layer_surface = zwlr_layer_shell_v1_get_layer_surface(
	    m_wayland.layer_shell, m_wayland.surface, nullptr,
	    ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, "waylight-overlay");

	if (!m_wayland.layer_surface) {
		if (m_wayland.eff) {
			ext_background_effect_surface_v1_destroy(m_wayland.eff);
			m_wayland.eff = nullptr;
		}
		if (m_wayland.kde_blur) {
			org_kde_kwin_blur_destroy(m_wayland.kde_blur);
			m_wayland.kde_blur = nullptr;
		}
		if (m_wayland.surface) {
			wl_surface_destroy(m_wayland.surface);
			m_wayland.surface = nullptr;
		}
		return;
	}

	zwlr_layer_surface_v1_set_anchor(m_wayland.layer_surface, 0);
	zwlr_layer_surface_v1_set_size(m_wayland.layer_surface, m_win_w, m_win_h);
	zwlr_layer_surface_v1_set_exclusive_zone(m_wayland.layer_surface, 0);

	if (zwlr_layer_shell_v1_get_version(m_wayland.layer_shell) >= 3) {
		zwlr_layer_surface_v1_set_keyboard_interactivity(
		    m_wayland.layer_surface,
		    ZWLR_LAYER_SURFACE_V1_KEYBOARD_INTERACTIVITY_ON_DEMAND);
	}

	auto handle_layer_configure = [](void *data, zwlr_layer_surface_v1 *ls,
	                                  u32 serial, u32 w, u32 h) -> void {
		auto *app = static_cast<App *>(data);
		if (w)
			app->m_win_w = static_cast<int>(w);
		if (h)
			app->m_win_h = static_cast<int>(h);

		zwlr_layer_surface_v1_ack_configure(ls, serial);

		if (app->m_gl.edpy != EGL_NO_DISPLAY) {
			if (!app->m_gl.wegl || app->m_gl.esurf == EGL_NO_SURFACE) {
				app->ensure_egl_surface();
			} else {
				wl_egl_window_resize(
				    app->m_gl.wegl, app->m_win_w, app->m_win_h, 0, 0);
				eglMakeCurrent(app->m_gl.edpy, app->m_gl.esurf, app->m_gl.esurf,
				    app->m_gl.ectx);
			}
		}

		app->update_blur_region();

		if (app->m_wayland.surface)
			wl_surface_commit(app->m_wayland.surface);
	};

	auto handle_layer_closed = [](void *data, zwlr_layer_surface_v1 *) -> void {
		static_cast<App *>(data)->m_running = false;
	};

	static zwlr_layer_surface_v1_listener const lsl = {
		.configure = handle_layer_configure,
		.closed = handle_layer_closed,
	};

	zwlr_layer_surface_v1_add_listener(m_wayland.layer_surface, &lsl, this);

	update_blur_region();

	if (m_wayland.surface)
		wl_surface_commit(m_wayland.surface);

	if (m_wayland.display)
		wl_display_roundtrip(m_wayland.display);

	ensure_egl_surface();

	m_visible = true;
}

auto App::destroy_layer_surface() -> void
{
	if (m_gl.edpy != EGL_NO_DISPLAY && m_gl.esurf != EGL_NO_SURFACE) {
		eglMakeCurrent(
		    m_gl.edpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
		eglDestroySurface(m_gl.edpy, m_gl.esurf);
		m_gl.esurf = EGL_NO_SURFACE;
	}

	if (m_gl.wegl) {
		wl_egl_window_destroy(m_gl.wegl);
		m_gl.wegl = nullptr;
	}

	if (m_wayland.eff) {
		ext_background_effect_surface_v1_destroy(m_wayland.eff);
		m_wayland.eff = nullptr;
	}

	if (m_wayland.kde_blur) {
		org_kde_kwin_blur_destroy(m_wayland.kde_blur);
		m_wayland.kde_blur = nullptr;
	}

	if (m_wayland.layer_surface) {
		zwlr_layer_surface_v1_destroy(m_wayland.layer_surface);
		m_wayland.layer_surface = nullptr;
	}

	if (m_wayland.surface) {
		wl_surface_destroy(m_wayland.surface);
		m_wayland.surface = nullptr;
	}

	if (m_wayland.display)
		wl_display_flush(m_wayland.display);

	m_visible = false;
}

auto App::ensure_egl_surface() -> void
{
	if (m_gl.edpy == EGL_NO_DISPLAY || m_gl.ectx == EGL_NO_CONTEXT)
		return;
	if (!m_wayland.surface)
		return;

	if (!m_gl.wegl)
		m_gl.wegl = wl_egl_window_create(m_wayland.surface, m_win_w, m_win_h);

	if (!m_gl.wegl)
		return;

	if (m_gl.esurf == EGL_NO_SURFACE) {
		m_gl.esurf = eglCreateWindowSurface(m_gl.edpy, m_gl.ecfg,
		    reinterpret_cast<EGLNativeWindowType>(m_gl.wegl), nullptr);
	}

	if (m_gl.esurf == EGL_NO_SURFACE)
		return;

	eglMakeCurrent(m_gl.edpy, m_gl.esurf, m_gl.esurf, m_gl.ectx);
	eglSwapInterval(m_gl.edpy, 1);
}

auto App::update_blur_region() -> void
{
	if (!m_wayland.compositor)
		return;
	if (!m_wayland.eff && !m_wayland.kde_blur)
		return;

	wl_region *region = wl_compositor_create_region(m_wayland.compositor);
	if (!region)
		return;

	wl_region_add(region, 0, 0, m_win_w - 50, m_win_h);

	if (m_wayland.eff)
		ext_background_effect_surface_v1_set_blur_region(m_wayland.eff, region);
	if (m_wayland.kde_blur)
		org_kde_kwin_blur_set_region(m_wayland.kde_blur, region);

	wl_region_destroy(region);
}

auto App::pump_events() -> void
{
	while (g_main_context_iteration(nullptr, false))
		;

	wl_display_dispatch_pending(m_wayland.display);
	wl_display_flush(m_wayland.display);

	pollfd fds[2] { { wl_display_get_fd(m_wayland.display), POLLIN, 0 },
		{ m_sfd, POLLIN, 0 } };

	auto prepared = (wl_display_prepare_read(m_wayland.display) == 0);
	auto ret = poll(fds, 2, 0);

	if (ret > 0 && (fds[0].revents & POLLIN)) {
		if (prepared) {
			wl_display_read_events(m_wayland.display);
			prepared = false;
		}
	} else if (prepared) {
		wl_display_cancel_read(m_wayland.display);
	}

	if (ret > 0 && (fds[1].revents & POLLIN)) {
		signalfd_siginfo si;
		while (read(m_sfd, &si, sizeof(si)) == sizeof(si)) {
			if (si.ssi_signo == SIGUSR1) {
				set_visible(!visible());
			}
		}
	}
}