/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "ScreenHelperGTK.h"

#ifdef MOZ_X11
#  include <gdk/gdkx.h>
#endif /* MOZ_X11 */
#ifdef MOZ_WAYLAND
#  include <gdk/gdkwayland.h>
#endif /* MOZ_WAYLAND */
#include <dlfcn.h>
#include <gtk/gtk.h>

#include "gfxPlatformGtk.h"
#include "mozilla/dom/DOMTypes.h"
#include "mozilla/Logging.h"
#include "mozilla/WidgetUtilsGtk.h"
#include "nsGtkUtils.h"
#include "nsTArray.h"

namespace mozilla {
namespace widget {

#ifdef MOZ_LOGGING
static LazyLogModule sScreenLog("WidgetScreen");
#  define LOG_SCREEN(args) MOZ_LOG(sScreenLog, LogLevel::Debug, args)
#else
#  define LOG_SCREEN(args)
#endif /* MOZ_LOGGING */

using GdkMonitor = struct _GdkMonitor;

static UniquePtr<ScreenGetter> gScreenGetter;

static void monitors_changed(GdkScreen* aScreen, gpointer aClosure) {
  LOG_SCREEN(("Received monitors-changed event"));
  ScreenGetterGtk* self = static_cast<ScreenGetterGtk*>(aClosure);
  self->RefreshScreens();
}

static void screen_resolution_changed(GdkScreen* aScreen, GParamSpec* aPspec,
                                      ScreenGetterGtk* self) {
  self->RefreshScreens();
}

static GdkFilterReturn root_window_event_filter(GdkXEvent* aGdkXEvent,
                                                GdkEvent* aGdkEvent,
                                                gpointer aClosure) {
#ifdef MOZ_X11
  ScreenGetterGtk* self = static_cast<ScreenGetterGtk*>(aClosure);
  XEvent* xevent = static_cast<XEvent*>(aGdkXEvent);

  switch (xevent->type) {
    case PropertyNotify: {
      XPropertyEvent* propertyEvent = &xevent->xproperty;
      if (propertyEvent->atom == self->NetWorkareaAtom()) {
        LOG_SCREEN(("Work area size changed"));
        self->RefreshScreens();
      }
    } break;
    default:
      break;
  }
#endif

  return GDK_FILTER_CONTINUE;
}

ScreenGetterGtk::ScreenGetterGtk()
    : mRootWindow(nullptr)
#ifdef MOZ_X11
      ,
      mNetWorkareaAtom(0)
#endif
{
}

void ScreenGetterGtk::Init() {
  LOG_SCREEN(("ScreenGetterGtk created"));
  GdkScreen* defaultScreen = gdk_screen_get_default();
  if (!defaultScreen) {
    // Sometimes we don't initial X (e.g., xpcshell)
    MOZ_LOG(sScreenLog, LogLevel::Debug,
            ("defaultScreen is nullptr, running headless"));
    return;
  }
  mRootWindow = gdk_get_default_root_window();
  MOZ_ASSERT(mRootWindow);

  g_object_ref(mRootWindow);

  // GDK_PROPERTY_CHANGE_MASK ==> PropertyChangeMask, for PropertyNotify
  gdk_window_set_events(mRootWindow,
                        GdkEventMask(gdk_window_get_events(mRootWindow) |
                                     GDK_PROPERTY_CHANGE_MASK));

  g_signal_connect(defaultScreen, "monitors-changed",
                   G_CALLBACK(monitors_changed), this);
  // Use _after to ensure this callback is run after gfxPlatformGtk.cpp's
  // handler.
  g_signal_connect_after(defaultScreen, "notify::resolution",
                         G_CALLBACK(screen_resolution_changed), this);
#ifdef MOZ_X11
  gdk_window_add_filter(mRootWindow, root_window_event_filter, this);
  if (GdkIsX11Display()) {
    mNetWorkareaAtom = XInternAtom(GDK_WINDOW_XDISPLAY(mRootWindow),
                                   "_NET_WORKAREA", X11False);
  }
#endif
  RefreshScreens();
}

ScreenGetterGtk::~ScreenGetterGtk() {
  if (mRootWindow) {
    g_signal_handlers_disconnect_by_data(gdk_screen_get_default(), this);

    gdk_window_remove_filter(mRootWindow, root_window_event_filter, this);
    g_object_unref(mRootWindow);
    mRootWindow = nullptr;
  }
}

static uint32_t GetGTKPixelDepth() {
  GdkVisual* visual = gdk_screen_get_system_visual(gdk_screen_get_default());
  return gdk_visual_get_depth(visual);
}

static already_AddRefed<Screen> MakeScreenGtk(GdkScreen* aScreen,
                                              gint aMonitorNum) {
  GdkRectangle monitor;
  GdkRectangle workarea;
  gdk_screen_get_monitor_geometry(aScreen, aMonitorNum, &monitor);
  gdk_screen_get_monitor_workarea(aScreen, aMonitorNum, &workarea);
  gint gdkScaleFactor = ScreenHelperGTK::GetGTKMonitorScaleFactor(aMonitorNum);

  // gdk_screen_get_monitor_geometry / workarea returns application pixels
  // (desktop pixels), so we need to convert it to device pixels with
  // gdkScaleFactor on X11.
  gint geometryScaleFactor = 1;
  if (GdkIsX11Display()) {
    geometryScaleFactor = gdkScaleFactor;
  }

  LayoutDeviceIntRect rect(monitor.x * geometryScaleFactor,
                           monitor.y * geometryScaleFactor,
                           monitor.width * geometryScaleFactor,
                           monitor.height * geometryScaleFactor);
  LayoutDeviceIntRect availRect(workarea.x * geometryScaleFactor,
                                workarea.y * geometryScaleFactor,
                                workarea.width * geometryScaleFactor,
                                workarea.height * geometryScaleFactor);

  uint32_t pixelDepth = GetGTKPixelDepth();

  // Use per-monitor scaling factor in gtk/wayland, or 1.0 otherwise.
  DesktopToLayoutDeviceScale contentsScale(1.0);
#ifdef MOZ_WAYLAND
  if (GdkIsWaylandDisplay()) {
    contentsScale.scale = gdkScaleFactor;
  }
#endif

  CSSToLayoutDeviceScale defaultCssScale(gdkScaleFactor *
                                         gfxPlatformGtk::GetFontScaleFactor());

  float dpi = 96.0f;
  gint heightMM = gdk_screen_get_monitor_height_mm(aScreen, aMonitorNum);
  if (heightMM > 0) {
    dpi = rect.height / (heightMM / MM_PER_INCH_FLOAT);
  }

  MOZ_LOG(sScreenLog, LogLevel::Debug,
          ("New screen [%d %d %d %d (%d %d %d %d) %d %f %f %f]", rect.x, rect.y,
           rect.width, rect.height, availRect.x, availRect.y, availRect.width,
           availRect.height, pixelDepth, contentsScale.scale,
           defaultCssScale.scale, dpi));
  RefPtr<Screen> screen = new Screen(rect, availRect, pixelDepth, pixelDepth,
                                     contentsScale, defaultCssScale, dpi);
  return screen.forget();
}

void ScreenGetterGtk::RefreshScreens() {
  LOG_SCREEN(("Refreshing screens"));
  AutoTArray<RefPtr<Screen>, 4> screenList;

  GdkScreen* defaultScreen = gdk_screen_get_default();
  gint numScreens = gdk_screen_get_n_monitors(defaultScreen);
  LOG_SCREEN(("GDK reports %d screens", numScreens));

  for (gint i = 0; i < numScreens; i++) {
    screenList.AppendElement(MakeScreenGtk(defaultScreen, i));
  }

  ScreenManager& screenManager = ScreenManager::GetSingleton();
  screenManager.Refresh(std::move(screenList));
}

#ifdef MOZ_WAYLAND
static void output_handle_geometry(void* data, struct wl_output* wl_output,
                                   int x, int y, int physical_width,
                                   int physical_height, int subpixel,
                                   const char* make, const char* model,
                                   int32_t transform) {
  MonitorConfig* monitor = (MonitorConfig*)data;
  LOG_SCREEN(("wl_output: geometry position %d %d physical size %d %d", x, y,
              physical_width, physical_height));
  monitor->x = x;
  monitor->y = y;
  monitor->width_mm = physical_width;
  monitor->height_mm = physical_height;
}

static void output_handle_done(void* data, struct wl_output* wl_output) {
  LOG_SCREEN(("done"));
  gScreenGetter->RefreshScreens();
}

static void output_handle_scale(void* data, struct wl_output* wl_output,
                                int32_t scale) {
  MonitorConfig* monitor = (MonitorConfig*)data;
  LOG_SCREEN(("wl_output: scale %d", scale));
  monitor->scale = scale;
}

static void output_handle_mode(void* data, struct wl_output* wl_output,
                               uint32_t flags, int width, int height,
                               int refresh) {
  MonitorConfig* monitor = (MonitorConfig*)data;

  LOG_SCREEN(("wl_output: mode output size %d x %d refresh %d", width, height,
              refresh));

  if ((flags & WL_OUTPUT_MODE_CURRENT) == 0) return;

  monitor->width = width;
  monitor->height = height;
}

static const struct wl_output_listener output_listener = {
    output_handle_geometry,
    output_handle_mode,
    output_handle_done,
    output_handle_scale,
};

static void screen_registry_handler(void* data, wl_registry* registry,
                                    uint32_t id, const char* interface,
                                    uint32_t version) {
  ScreenGetterWayland* getter = static_cast<ScreenGetterWayland*>(data);
  if (strcmp(interface, "wl_output") == 0 && version > 1) {
    auto* output =
        WaylandRegistryBind<wl_output>(registry, id, &wl_output_interface, 2);
    wl_output_add_listener(output, &output_listener,
                           getter->AddMonitorConfig(id));
  }
}

static void screen_registry_remover(void* data, struct wl_registry* registry,
                                    uint32_t id) {
  auto* getter = static_cast<ScreenGetterWayland*>(data);
  if (getter->RemoveMonitorConfig(id)) {
    getter->RefreshScreens();
  }
  /* TODO: the object needs to be destroyed here, we're leaking */
}

static const struct wl_registry_listener screen_registry_listener = {
    screen_registry_handler, screen_registry_remover};

void ScreenGetterWayland::Init() {
  MOZ_ASSERT(GdkIsWaylandDisplay());
  LOG_SCREEN(("ScreenGetterWayland created"));
  wl_display* display = WaylandDisplayGetWLDisplay();
  mRegistry = wl_display_get_registry(display);
  wl_registry_add_listener((wl_registry*)mRegistry, &screen_registry_listener,
                           this);
  wl_display_roundtrip(display);
  wl_display_roundtrip(display);
}

MonitorConfig* ScreenGetterWayland::AddMonitorConfig(int aId) {
  mMonitors.EmplaceBack(aId);
  LOG_SCREEN(("Add Monitor ID %d num %d", aId, (int)(mMonitors.Length() - 1)));
  return &(mMonitors[mMonitors.Length() - 1]);
}

bool ScreenGetterWayland::RemoveMonitorConfig(int aId) {
  for (unsigned int i = 0; i < mMonitors.Length(); i++) {
    if (mMonitors[i].id == aId) {
      LOG_SCREEN(("Remove Monitor ID %d num %d", aId, i));
      mMonitors.RemoveElementAt(i);
      return true;
    }
  }
  return false;
}

ScreenGetterWayland::~ScreenGetterWayland() {
  g_clear_pointer(&mRegistry, wl_registry_destroy);
}

static bool GdkMonitorGetWorkarea(GdkMonitor* monitor, GdkRectangle* workarea) {
  static auto s_gdk_monitor_get_workarea =
      (void (*)(GdkMonitor*, GdkRectangle*))dlsym(RTLD_DEFAULT,
                                                  "gdk_monitor_get_workarea");
  if (!s_gdk_monitor_get_workarea) {
    return false;
  }

  s_gdk_monitor_get_workarea(monitor, workarea);
  return true;
}

bool ScreenGetterWayland::MonitorUsesNonIntegerScale(int aMonitor) {
  static auto s_gdk_display_get_n_monitors =
      (int (*)(GdkDisplay*))dlsym(RTLD_DEFAULT, "gdk_display_get_n_monitors");
  static auto s_gdk_display_get_monitor = (GdkMonitor * (*)(GdkDisplay*, int))
      dlsym(RTLD_DEFAULT, "gdk_display_get_monitor");

  if (!s_gdk_display_get_n_monitors || !s_gdk_display_get_monitor) {
    return false;
  }

  int monitorNum = s_gdk_display_get_n_monitors(gdk_display_get_default());
  for (int m = 0; m < monitorNum; m++) {
    GdkMonitor* gdkMonitor =
        s_gdk_display_get_monitor(gdk_display_get_default(), m);
    if (!gdkMonitor) {
      return false;
    }
    GdkRectangle workArea;
    if (!GdkMonitorGetWorkarea(gdkMonitor, &workArea)) {
      return false;
    }

    LOG_SCREEN(("Monitor %d Gtk workarea size %d x %d", m, workArea.width,
                workArea.height));
    LOG_SCREEN(("Monitor %d wl_output size %d x %d", aMonitor,
                mMonitors[aMonitor].width, mMonitors[aMonitor].height));

    if (mMonitors[aMonitor].x == workArea.x &&
        mMonitors[aMonitor].y == workArea.y) {
      // When non-integer scale is used, wl_output reports framebuffer size
      // but Gtk reports downscaled logical size.
      return workArea.width < mMonitors[aMonitor].width &&
             workArea.height < mMonitors[aMonitor].height;
    }
  }
  return false;
}

already_AddRefed<Screen> ScreenGetterWayland::MakeScreenWayland(gint aMonitor) {
  MonitorConfig monitor = mMonitors[aMonitor];

  LayoutDeviceIntRect rect(monitor.x, monitor.y, monitor.width, monitor.height);

  // Non integer scales are downscaled from upper scales so report screen sizes
  // as bigger ones.
  if (MonitorUsesNonIntegerScale(aMonitor)) {
    LOG_SCREEN(("Monitor %d uses non-integer scale", aMonitor));
    rect.width *= monitor.scale;
    rect.height *= monitor.scale;
  }

  uint32_t pixelDepth = GetGTKPixelDepth();

  // Use per-monitor scaling factor in gtk/wayland, or 1.0 otherwise.
  DesktopToLayoutDeviceScale contentsScale(1.0);
  contentsScale.scale = monitor.scale;

  CSSToLayoutDeviceScale defaultCssScale(monitor.scale *
                                         gfxPlatformGtk::GetFontScaleFactor());

  float dpi = 96.0f;
  gint heightMM = monitor.height_mm;
  if (heightMM > 0) {
    dpi = rect.height / (heightMM / MM_PER_INCH_FLOAT);
  }

  LOG_SCREEN(
      ("Monitor %d [%d %d -> %d x %d depth %d content scale %f css scale %f "
       "DPI %f]",
       aMonitor, rect.x, rect.y, rect.width, rect.height, pixelDepth,
       contentsScale.scale, defaultCssScale.scale, dpi));
  RefPtr<Screen> screen = new Screen(rect, rect, pixelDepth, pixelDepth,
                                     contentsScale, defaultCssScale, dpi);
  return screen.forget();
}

void ScreenGetterWayland::RefreshScreens() {
  LOG_SCREEN(("Refreshing screens"));
  AutoTArray<RefPtr<Screen>, 4> managerScreenList;

  mScreenList.Clear();
  const gint numScreens = mMonitors.Length();
  for (gint i = 0; i < numScreens; i++) {
    RefPtr<Screen> screen = MakeScreenWayland(i);
    mScreenList.AppendElement(screen);
    managerScreenList.AppendElement(screen);
  }

  ScreenManager& screenManager = ScreenManager::GetSingleton();
  screenManager.Refresh(std::move(managerScreenList));
}

int ScreenGetterWayland::GetMonitorForWindow(nsWindow* aWindow) {
  LOG_SCREEN(("GetMonitorForWindow() [%p]", aWindow));

  static auto s_gdk_display_get_monitor_at_window =
      (GdkMonitor * (*)(GdkDisplay*, GdkWindow*))
          dlsym(RTLD_DEFAULT, "gdk_display_get_monitor_at_window");

  if (!s_gdk_display_get_monitor_at_window) {
    LOG_SCREEN(("  failed, missing Gtk helpers"));
    return -1;
  }

  GdkWindow* gdkWindow = gtk_widget_get_window(aWindow->GetGtkWidget());
  if (!gdkWindow) {
    LOG_SCREEN(("  failed, can't get GdkWindow"));
    return -1;
  }

  GdkMonitor* monitor =
      s_gdk_display_get_monitor_at_window(gdk_display_get_default(), gdkWindow);
  if (!monitor) {
    LOG_SCREEN(("  failed, can't get monitor for GdkWindow"));
    return -1;
  }

  GdkRectangle workArea;
  if (!GdkMonitorGetWorkarea(monitor, &workArea)) {
    return -1;
  }

  for (unsigned int i = 0; i < mMonitors.Length(); i++) {
    // Although Gtk/Mutter are very creative in reporting various screens sizes
    // we can rely on Gtk work area start position to match wl_output.
    if (mMonitors[i].x == workArea.x && mMonitors[i].y == workArea.y) {
      LOG_SCREEN((" monitor %d values %d %d -> %d x %d", i, mMonitors[i].x,
                  mMonitors[i].y, mMonitors[i].width, mMonitors[i].height));
      return i;
    }
  }

  return -1;
}

RefPtr<nsIScreen> ScreenGetterWayland::GetScreenForWindow(nsWindow* aWindow) {
  if (mScreenList.IsEmpty()) {
    return nullptr;
  }

  int monitor = GetMonitorForWindow(aWindow);
  if (monitor < 0) {
    return nullptr;
  }
  return mScreenList[monitor];
}

void ScreenGetterWayland::GetScreenRectForWindow(nsWindow* aWindow,
                                                 GdkRectangle* aRect) {
  int monitor = GetMonitorForWindow(aWindow);
  if (monitor < 0) {
    // fallback to first monitor
    monitor = 0;
  }
  aRect->x = aRect->y = 0;
  aRect->width = mMonitors[monitor].width;
  aRect->height = mMonitors[monitor].height;
}
#endif

RefPtr<nsIScreen> ScreenHelperGTK::GetScreenForWindow(nsWindow* aWindow) {
  return gScreenGetter->GetScreenForWindow(aWindow);
}

void ScreenHelperGTK::GetScreenRectForWindow(nsWindow* aWindow,
                                             GdkRectangle* aRect) {
  gScreenGetter->GetScreenRectForWindow(aWindow, aRect);
}

gint ScreenHelperGTK::GetGTKMonitorScaleFactor(gint aMonitorNum) {
  GdkScreen* screen = gdk_screen_get_default();
  return gdk_screen_get_monitor_scale_factor(screen, aMonitorNum);
}

ScreenHelperGTK::ScreenHelperGTK() {
#ifdef MOZ_WAYLAND
  // Use ScreenGetterWayland on Gnome/Mutter only. It uses additional wl_output
  // to track screen size changes (which are wrongly reported by mutter)
  // and causes issues on Sway (Bug 1730476).
  const char* currentDesktop = getenv("XDG_CURRENT_DESKTOP");
  if (GdkIsWaylandDisplay() && currentDesktop &&
      strstr(currentDesktop, "GNOME")) {
    gScreenGetter = mozilla::MakeUnique<ScreenGetterWayland>();
  }
#endif
  if (!gScreenGetter) {
    gScreenGetter = mozilla::MakeUnique<ScreenGetterGtk>();
  }
  gScreenGetter->Init();
}

ScreenHelperGTK::~ScreenHelperGTK() { gScreenGetter = nullptr; }

}  // namespace widget
}  // namespace mozilla