#include <cassert>
#include <csignal>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <poll.h>
#include <sys/file.h>
#include <sys/signalfd.h>
#include <thread>

#include <EGL/egl.h>
#include <GLES3/gl3.h>
#include <glib.h>
#include <libportal/portal.h>
#include <raylib.h>
#include <rlgl.h>
#include <wayland-egl.h>

#define namespace namespace_
#include "wlr-layer-shell-unstable-v1-client-protocol.h"
extern "C" {
#include <libportal/settings.h>
}
#undef namespace

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

#include <wayland-client.h>

#include "Theme.hpp"

struct App {
  App() {
    init_wayland();
    init_egl();
    init_signal();
    init_theme_portal();
  }
  ~App();

  auto run() -> void {
    SetWindowSize(m_win_w, m_win_h);
    while (m_running) {
      pump_events();
      render_frame();
      std::this_thread::sleep_for(std::chrono::milliseconds(16));
    }
  }
  auto set_visible(bool visible) -> void;
  auto visible() const -> bool { return m_visible; }

private:
  auto init_wayland() -> void;
  auto init_egl() -> void;
  auto init_signal() -> void;
  auto init_theme_portal() -> void;
  auto pump_events() -> void;
  auto render_frame() -> void;
  auto theme() const -> ColorScheme const & { return m_themes[m_active_theme]; }

  static void on_settings_changed(XdpSettings * /*self*/, const char *ns,
                                  const char *key, GVariant * /*value*/,
                                  gpointer data);

  struct {
    wl_display *display{};
    wl_registry *registry{};
    wl_compositor *compositor{};
    wl_surface *wl_surface{};
    zwlr_layer_shell_v1 *layer_shell{};
    zwlr_layer_surface_v1 *layer_surface{};
    ext_background_effect_manager_v1 *mgr{};
    ext_background_effect_surface_v1 *eff{};
    org_kde_kwin_blur_manager *kde_blur_mgr{};
    org_kde_kwin_blur *kde_blur{};
  } m_wayland;

  struct {
    EGLDisplay edpy{EGL_NO_DISPLAY};
    EGLConfig ecfg{};
    EGLContext ectx{EGL_NO_CONTEXT};
    EGLSurface esurf{EGL_NO_SURFACE};
    wl_egl_window *wegl{};
  } m_gl;

  struct {
    XdpPortal *portal{};
    XdpSettings *settings{};
  } m_xdp;

  enum_array<Theme, ColorScheme> m_themes{make_default_themes()};
  Theme m_active_theme{Theme::Light};

  int m_win_w{800};
  int m_win_h{600};
  bool m_running{true};
  bool m_visible{true};

  int m_sfd{-1}; // Signal fd for toggling visibility
};

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

  if (m_gl.edpy != EGL_NO_DISPLAY) {
    eglMakeCurrent(m_gl.edpy, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    if (m_gl.esurf != EGL_NO_SURFACE)
      eglDestroySurface(m_gl.edpy, m_gl.esurf);
    if (m_gl.wegl)
      wl_egl_window_destroy(m_gl.wegl);
    if (m_gl.ectx != EGL_NO_CONTEXT)
      eglDestroyContext(m_gl.edpy, m_gl.ectx);
    eglTerminate(m_gl.edpy);
  }

  if (m_wayland.wl_surface)
    wl_surface_destroy(m_wayland.wl_surface);
  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::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);
  }

  auto handle_registry_global = [](void *data, wl_registry *registry,
                                   uint32_t name, const char *interface,
                                   uint32_t 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 (strcmp(interface, zwlr_layer_shell_v1_interface.name) == 0) {
      app->m_wayland.layer_shell = (zwlr_layer_shell_v1 *)wl_registry_bind(
          registry, name, &zwlr_layer_shell_v1_interface,
          version >= 4 ? 4 : version);
    } else if (strcmp(interface,
                      ext_background_effect_manager_v1_interface.name) == 0) {
      app->m_wayland.mgr = (ext_background_effect_manager_v1 *)wl_registry_bind(
          registry, name, &ext_background_effect_manager_v1_interface, 1);
    } else if (strcmp(interface, "org_kde_kwin_blur_manager") == 0) {
      app->m_wayland.kde_blur_mgr =
          (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 *, uint32_t) {},
  };

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

  wl_display_roundtrip(m_wayland.display);

  m_wayland.wl_surface = wl_compositor_create_surface(m_wayland.compositor);
  if (m_wayland.mgr && !m_wayland.eff) {
    m_wayland.eff = ext_background_effect_manager_v1_get_background_effect(
        m_wayland.mgr, m_wayland.wl_surface);
  }
  if (m_wayland.kde_blur_mgr && !m_wayland.kde_blur) {
    m_wayland.kde_blur = org_kde_kwin_blur_manager_create(
        m_wayland.kde_blur_mgr, m_wayland.wl_surface);
  }

  auto apply_blur_full_surface = [&] {
    wl_region *r = wl_compositor_create_region(m_wayland.compositor);
    wl_region_add(r, 0, 0, m_win_w, m_win_h);
    if (m_wayland.eff) {
      ext_background_effect_surface_v1_set_blur_region(m_wayland.eff, r);
    }
    if (m_wayland.kde_blur) {
      org_kde_kwin_blur_set_region(m_wayland.kde_blur, r);
    }
    wl_region_destroy(r);
  };

  m_wayland.layer_surface = zwlr_layer_shell_v1_get_layer_surface(
      m_wayland.layer_shell, m_wayland.wl_surface, /*output*/ nullptr,
      ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY, "waylight-overlay");

  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,
                                   uint32_t serial, uint32_t w,
                                   uint32_t h) -> void {
    auto *app = static_cast<App *>(data);
    app->m_win_w = (int)(w ? w : app->m_win_w);
    app->m_win_h = (int)(h ? h : app->m_win_h);

    zwlr_layer_surface_v1_ack_configure(ls, serial);

    if (!app->m_gl.wegl) {
      app->m_gl.wegl = wl_egl_window_create(app->m_wayland.wl_surface,
                                            app->m_win_w, app->m_win_h);
      app->m_gl.esurf =
          eglCreateWindowSurface(app->m_gl.edpy, app->m_gl.ecfg,
                                 (EGLNativeWindowType)app->m_gl.wegl, nullptr);
      eglMakeCurrent(app->m_gl.edpy, app->m_gl.esurf, app->m_gl.esurf,
                     app->m_gl.ectx);
      eglSwapInterval(app->m_gl.edpy, 1);
    } else {
      wl_egl_window_resize(app->m_gl.wegl, app->m_win_w, app->m_win_h, 0, 0);
    }

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

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

  static const zwlr_layer_surface_v1_listener lsl = {
      .configure = handle_layer_configure,
      .closed = handle_layer_closed,
  };
  zwlr_layer_surface_v1_add_listener(m_wayland.layer_surface, &lsl, this);

  apply_blur_full_surface();

  wl_surface_commit(m_wayland.wl_surface);
  wl_display_roundtrip(m_wayland.display);
}

auto App::set_visible(bool visible) -> void {
  if (!m_wayland.layer_surface)
    return;

  if (visible) {
    zwlr_layer_surface_v1_set_size(m_wayland.layer_surface, m_win_w, m_win_h);
    wl_surface_commit(m_wayland.wl_surface);
  } else {
    wl_surface_attach(m_wayland.wl_surface, nullptr, 0, 0);
    wl_surface_commit(m_wayland.wl_surface);
  }
  wl_display_flush(m_wayland.display);

  m_visible = visible;
}

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

  const EGLint 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);

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

  m_gl.wegl = wl_egl_window_create(m_wayland.wl_surface, m_win_w, m_win_h);
  m_gl.esurf = eglCreateWindowSurface(
      m_gl.edpy, m_gl.ecfg, reinterpret_cast<EGLNativeWindowType>(m_gl.wegl),
      nullptr);

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

  InitWindow(m_win_w, m_win_h, "");
}

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*/, const char *ns,
                              const char *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::render_frame() -> void {
  glViewport(0, 0, m_win_w, m_win_h);

  BeginDrawing();

  ClearBackground(theme().window.background);

  DrawFPS(10, 10);

  EndDrawing();

  eglSwapBuffers(m_gl.edpy, m_gl.esurf);
}

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);

  // Wayland
  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);
  }

  // Signals
  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());
      }
    }
  }
}

bool check_or_signal_running() {
  const char *lock_path = "/tmp/waylight.lock";
  int fd = open(lock_path, O_CREAT | O_RDWR, 0666);
  if (fd == -1)
    return false;

  if (flock(fd, LOCK_EX | LOCK_NB) == -1) {
    FILE *f = fopen(lock_path, "r");
    if (f) {
      pid_t pid;
      if (fscanf(f, "%d", &pid) == 1)
        kill(pid, SIGUSR1);
      fclose(f);
    }
    close(fd);
    return true;
  }

  ftruncate(fd, 0);
  dprintf(fd, "%d\n", getpid());
  return false;
}

auto main() -> int {
  if (check_or_signal_running()) {
    return 0;
  }

  App app;
  app.run();
}