// Copyright 2018 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "sommelier.h"  // NOLINT(build/include_directory)

#include <assert.h>
#include <math.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <unistd.h>
#include <wayland-client.h>
#include <wayland-util.h>

#include "keyboard-extension-unstable-v1-client-protocol.h"  // NOLINT(build/include_directory)

struct sl_host_keyboard {
  struct sl_seat* seat;
  struct wl_resource* resource;
  struct wl_keyboard* proxy;
  struct zcr_extended_keyboard_v1* extended_keyboard_proxy;
  struct wl_resource* focus_resource;
  struct wl_listener focus_resource_listener;
  uint32_t focus_serial;
  struct xkb_keymap* keymap;
  struct xkb_state* state;
  xkb_mod_mask_t control_mask;
  xkb_mod_mask_t alt_mask;
  xkb_mod_mask_t shift_mask;
  uint32_t modifiers;
  struct wl_array pressed_keys;
};

struct sl_host_touch {
  struct sl_seat* seat;
  struct wl_resource* resource;
  struct wl_touch* proxy;
  struct wl_resource* focus_resource;
  struct wl_listener focus_resource_listener;
};

static void sl_host_pointer_set_cursor(struct wl_client* client,
                                       struct wl_resource* resource,
                                       uint32_t serial,
                                       struct wl_resource* surface_resource,
                                       int32_t hotspot_x,
                                       int32_t hotspot_y) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_resource_get_user_data(resource));
  struct sl_host_surface* host_surface = NULL;
  double scale = host->seat->ctx->scale;

  if (surface_resource) {
    host_surface = static_cast<sl_host_surface*>(
        wl_resource_get_user_data(surface_resource));
    host_surface->has_role = 1;
    if (host_surface->contents_width && host_surface->contents_height)
      wl_surface_commit(host_surface->proxy);
  }

  wl_pointer_set_cursor(host->proxy, serial,
                        host_surface ? host_surface->proxy : NULL,
                        hotspot_x / scale, hotspot_y / scale);
}  // NOLINT(whitespace/indent)

static void sl_host_pointer_release(struct wl_client* client,
                                    struct wl_resource* resource) {
  wl_resource_destroy(resource);
}

static const struct wl_pointer_interface sl_pointer_implementation = {
    sl_host_pointer_set_cursor, sl_host_pointer_release};

static void sl_set_last_event_serial(struct wl_resource* surface_resource,
                                     uint32_t serial) {
  struct sl_host_surface* host_surface = static_cast<sl_host_surface*>(
      wl_resource_get_user_data(surface_resource));

  host_surface->last_event_serial = serial;
}

static void sl_pointer_set_focus(struct sl_host_pointer* host,
                                 uint32_t serial,
                                 struct sl_host_surface* host_surface,
                                 wl_fixed_t x,
                                 wl_fixed_t y) {
  struct wl_resource* surface_resource =
      host_surface ? host_surface->resource : NULL;

  if (surface_resource == host->focus_resource)
    return;

  if (host->focus_resource)
    wl_pointer_send_leave(host->resource, serial, host->focus_resource);

  wl_list_remove(&host->focus_resource_listener.link);
  wl_list_init(&host->focus_resource_listener.link);
  host->focus_resource = surface_resource;
  host->focus_serial = serial;

  if (surface_resource) {
    double scale = host->seat->ctx->scale;

    if (host->seat->ctx->xwayland) {
      // Make sure focus surface is on top before sending enter event.
      sl_restack_windows(host->seat->ctx, wl_resource_get_id(surface_resource));
      sl_roundtrip(host->seat->ctx);
    }

    wl_resource_add_destroy_listener(surface_resource,
                                     &host->focus_resource_listener);

    wl_pointer_send_enter(host->resource, serial, surface_resource, x * scale,
                          y * scale);
  }
}

static void sl_pointer_enter(void* data,
                             struct wl_pointer* pointer,
                             uint32_t serial,
                             struct wl_surface* surface,
                             wl_fixed_t x,
                             wl_fixed_t y) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));
  struct sl_host_surface* host_surface =
      surface ? static_cast<sl_host_surface*>(wl_surface_get_user_data(surface))
              : NULL;

  if (!host_surface)
    return;

  sl_pointer_set_focus(host, serial, host_surface, x, y);

  if (host->focus_resource)
    sl_set_last_event_serial(host->focus_resource, serial);
  host->seat->last_serial = serial;
}  // NOLINT(whitespace/indent)

static void sl_pointer_leave(void* data,
                             struct wl_pointer* pointer,
                             uint32_t serial,
                             struct wl_surface* surface) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));

  sl_pointer_set_focus(host, serial, NULL, 0, 0);
}

static void sl_pointer_motion(void* data,
                              struct wl_pointer* pointer,
                              uint32_t time,
                              wl_fixed_t x,
                              wl_fixed_t y) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));
  double scale = host->seat->ctx->scale;

  wl_pointer_send_motion(host->resource, time, x * scale, y * scale);
}

static void sl_pointer_button(void* data,
                              struct wl_pointer* pointer,
                              uint32_t serial,
                              uint32_t time,
                              uint32_t button,
                              uint32_t state) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));

  wl_pointer_send_button(host->resource, serial, time, button, state);

  if (host->focus_resource)
    sl_set_last_event_serial(host->focus_resource, serial);
  host->seat->last_serial = serial;
}

static void sl_pointer_axis(void* data,
                            struct wl_pointer* pointer,
                            uint32_t time,
                            uint32_t axis,
                            wl_fixed_t value) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));
  double scale = host->seat->ctx->scale;

  host->time = time;
  host->axis_delta[axis] += value * scale;
}

static void sl_pointer_frame(void* data, struct wl_pointer* pointer) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));

  // Many X apps (e.g. VS Code, Firefox, Chromium) only allow scrolls to happen
  // in multiples of 5 units. This value comes from the smooth scrolling
  // extension of X, which says that 5 smooth scroll units is equal to 1 tick of
  // discrete scrolling.
  //
  // To avoid the experience of scrolling and seeing nothing happen, we replace
  // scroll amounts < 5 with 5 units, for discrete scrolls for X apps
  // only. Other clients should continue to see smaller scrolls as they can
  // handle them correctly, and for non-discrete scrolling (such as touch-pads)
  // we don't want to do this because it would lead to erratic jumps.
  const int kDiscreteScrollUnit = 5;

  for (int axis = 0; axis < 2; axis++) {
    if (host->axis_discrete[axis] != 0) {
      wl_pointer_send_axis_discrete(host->resource, axis,
                                    host->axis_discrete[axis]);

      double axis_delta = wl_fixed_to_double(host->axis_delta[axis]);
      if (fabs(axis_delta) < kDiscreteScrollUnit && host->seat->ctx->xwayland) {
        axis_delta = copysign(kDiscreteScrollUnit, axis_delta);
        host->axis_delta[axis] = wl_fixed_from_double(axis_delta);
      }
    }
    if (host->axis_delta[axis] != 0) {
      wl_pointer_send_axis(host->resource, host->time, axis,
                           host->axis_delta[axis]);
    }

    host->axis_delta[axis] = wl_fixed_from_int(0);
    host->axis_discrete[axis] = 0;
  }

  wl_pointer_send_frame(host->resource);
}

void sl_pointer_axis_source(void* data,
                            struct wl_pointer* pointer,
                            uint32_t axis_source) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));

  wl_pointer_send_axis_source(host->resource, axis_source);
}

static void sl_pointer_axis_stop(void* data,
                                 struct wl_pointer* pointer,
                                 uint32_t time,
                                 uint32_t axis) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));

  wl_pointer_send_axis_stop(host->resource, time, axis);
}

static void sl_pointer_axis_discrete(void* data,
                                     struct wl_pointer* pointer,
                                     uint32_t axis,
                                     int32_t discrete) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_pointer_get_user_data(pointer));

  host->axis_discrete[axis] += discrete;
}

static const struct wl_pointer_listener sl_pointer_listener = {
    sl_pointer_enter,       sl_pointer_leave,     sl_pointer_motion,
    sl_pointer_button,      sl_pointer_axis,      sl_pointer_frame,
    sl_pointer_axis_source, sl_pointer_axis_stop, sl_pointer_axis_discrete};

static void sl_host_keyboard_release(struct wl_client* client,
                                     struct wl_resource* resource) {
  wl_resource_destroy(resource);
}

static const struct wl_keyboard_interface sl_keyboard_implementation = {
    sl_host_keyboard_release};

static void sl_keyboard_keymap(void* data,
                               struct wl_keyboard* keyboard,
                               uint32_t format,
                               int32_t fd,
                               uint32_t size) {
  struct sl_host_keyboard* host =
      static_cast<sl_host_keyboard*>(wl_keyboard_get_user_data(keyboard));

  wl_keyboard_send_keymap(host->resource, format, fd, size);

  if (format == WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
    void* data = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);

    assert(data != MAP_FAILED);

    if (host->keymap)
      xkb_keymap_unref(host->keymap);

    host->keymap = xkb_keymap_new_from_string(
        host->seat->ctx->xkb_context, static_cast<char*>(data),
        XKB_KEYMAP_FORMAT_TEXT_V1,
        static_cast<xkb_keymap_compile_flags>(XKB_KEYMAP_COMPILE_NO_FLAGS));
    assert(host->keymap);

    munmap(data, size);

    if (host->state)
      xkb_state_unref(host->state);
    host->state = xkb_state_new(host->keymap);
    assert(host->state);

    host->control_mask = 1 << xkb_keymap_mod_get_index(host->keymap, "Control");
    host->alt_mask = 1 << xkb_keymap_mod_get_index(host->keymap, "Mod1");
    host->shift_mask = 1 << xkb_keymap_mod_get_index(host->keymap, "Shift");
  }

  close(fd);
}

static void sl_keyboard_set_focus(struct sl_host_keyboard* host,
                                  uint32_t serial,
                                  struct sl_host_surface* host_surface,
                                  struct wl_array* keys) {
  struct wl_resource* surface_resource =
      host_surface ? host_surface->resource : NULL;

  if (surface_resource == host->focus_resource)
    return;

  if (host->focus_resource)
    wl_keyboard_send_leave(host->resource, serial, host->focus_resource);

  wl_list_remove(&host->focus_resource_listener.link);
  wl_list_init(&host->focus_resource_listener.link);
  host->focus_resource = surface_resource;
  host->focus_serial = serial;

  if (surface_resource) {
    wl_resource_add_destroy_listener(surface_resource,
                                     &host->focus_resource_listener);
    wl_keyboard_send_enter(host->resource, serial, surface_resource, keys);
  }

  host->seat->last_serial = serial;
}

static void sl_keyboard_enter(void* data,
                              struct wl_keyboard* keyboard,
                              uint32_t serial,
                              struct wl_surface* surface,
                              struct wl_array* keys) {
  struct sl_host_keyboard* host =
      static_cast<sl_host_keyboard*>(wl_keyboard_get_user_data(keyboard));
  struct sl_host_surface* host_surface =
      surface ? static_cast<sl_host_surface*>(wl_surface_get_user_data(surface))
              : NULL;

  if (!host_surface)
    return;

  wl_array_copy(&host->pressed_keys, keys);
  sl_keyboard_set_focus(host, serial, host_surface, keys);

  host->seat->last_serial = serial;
}  // NOLINT(whitespace/indent)

static void sl_keyboard_leave(void* data,
                              struct wl_keyboard* keyboard,
                              uint32_t serial,
                              struct wl_surface* surface) {
  struct sl_host_keyboard* host =
      static_cast<sl_host_keyboard*>(wl_keyboard_get_user_data(keyboard));
  struct wl_array array;

  wl_array_init(&array);
  sl_keyboard_set_focus(host, serial, NULL, &array);
}

static int sl_array_set_add(struct wl_array* array, uint32_t key) {
  uint32_t* k;

  sl_array_for_each(k, array) {
    if (*k == key)
      return 0;
  }
  k = static_cast<uint32_t*>(wl_array_add(array, sizeof(key)));
  assert(k);
  *k = key;
  return 1;
}

static int sl_array_set_remove(struct wl_array* array, uint32_t key) {
  uint32_t* k;

  sl_array_for_each(k, array) {
    if (*k == key) {
      uint32_t* end = reinterpret_cast<uint32_t*>(
          reinterpret_cast<char*>(array->data) + array->size);

      *k = *(end - 1);
      array->size -= sizeof(*k);
      return 1;
    }
  }
  return 0;
}

static void sl_keyboard_key(void* data,
                            struct wl_keyboard* keyboard,
                            uint32_t serial,
                            uint32_t time,
                            uint32_t key,
                            uint32_t state) {
  struct sl_host_keyboard* host =
      static_cast<sl_host_keyboard*>(wl_keyboard_get_user_data(keyboard));
  int handled = 1;

  if (state == WL_KEYBOARD_KEY_STATE_PRESSED) {
    if (host->state) {
      const xkb_keysym_t* symbols;
      uint32_t num_symbols;
      xkb_keysym_t symbol = XKB_KEY_NoSymbol;
      uint32_t code = key + 8;
      struct sl_accelerator* accelerator;

      num_symbols = xkb_state_key_get_syms(host->state, code, &symbols);
      if (num_symbols == 1)
        symbol = symbols[0];

      wl_list_for_each(accelerator, &host->seat->ctx->accelerators, link) {
        if (host->modifiers != accelerator->modifiers)
          continue;
        if (symbol != accelerator->symbol)
          continue;

        handled = 0;
        break;
      }
    }

    // Forward key pressed event if it should be handled and not
    // already pressed.
    if (handled) {
      if (sl_array_set_add(&host->pressed_keys, key))
        wl_keyboard_send_key(host->resource, serial, time, key, state);
    }
  } else {
    // Forward key release event if currently pressed.
    handled = sl_array_set_remove(&host->pressed_keys, key);
    if (handled)
      wl_keyboard_send_key(host->resource, serial, time, key, state);
  }

  if (host->focus_resource)
    sl_set_last_event_serial(host->focus_resource, serial);
  host->seat->last_serial = serial;

  if (host->extended_keyboard_proxy) {
    zcr_extended_keyboard_v1_ack_key(
        host->extended_keyboard_proxy, serial,
        handled ? ZCR_EXTENDED_KEYBOARD_V1_HANDLED_STATE_HANDLED
                : ZCR_EXTENDED_KEYBOARD_V1_HANDLED_STATE_NOT_HANDLED);
  }
}

static void sl_keyboard_modifiers(void* data,
                                  struct wl_keyboard* keyboard,
                                  uint32_t serial,
                                  uint32_t mods_depressed,
                                  uint32_t mods_latched,
                                  uint32_t mods_locked,
                                  uint32_t group) {
  struct sl_host_keyboard* host =
      static_cast<sl_host_keyboard*>(wl_keyboard_get_user_data(keyboard));
  xkb_mod_mask_t mask;

  wl_keyboard_send_modifiers(host->resource, serial, mods_depressed,
                             mods_latched, mods_locked, group);

  if (host->focus_resource)
    sl_set_last_event_serial(host->focus_resource, serial);
  host->seat->last_serial = serial;

  if (!host->keymap)
    return;

  xkb_state_update_mask(host->state, mods_depressed, mods_latched, mods_locked,
                        0, 0, group);
  mask = xkb_state_serialize_mods(
      host->state, static_cast<xkb_state_component>(XKB_STATE_MODS_DEPRESSED |
                                                    XKB_STATE_MODS_LATCHED));
  host->modifiers = 0;
  if (mask & host->control_mask)
    host->modifiers |= CONTROL_MASK;
  if (mask & host->alt_mask)
    host->modifiers |= ALT_MASK;
  if (mask & host->shift_mask)
    host->modifiers |= SHIFT_MASK;
}

static void sl_keyboard_repeat_info(void* data,
                                    struct wl_keyboard* keyboard,
                                    int32_t rate,
                                    int32_t delay) {
  struct sl_host_keyboard* host =
      static_cast<sl_host_keyboard*>(wl_keyboard_get_user_data(keyboard));

  wl_keyboard_send_repeat_info(host->resource, rate, delay);
}

static const struct wl_keyboard_listener sl_keyboard_listener = {
    sl_keyboard_keymap, sl_keyboard_enter,     sl_keyboard_leave,
    sl_keyboard_key,    sl_keyboard_modifiers, sl_keyboard_repeat_info};

static void sl_host_touch_release(struct wl_client* client,
                                  struct wl_resource* resource) {
  wl_resource_destroy(resource);
}

static const struct wl_touch_interface sl_touch_implementation = {
    sl_host_touch_release};

static void sl_host_touch_down(void* data,
                               struct wl_touch* touch,
                               uint32_t serial,
                               uint32_t time,
                               struct wl_surface* surface,
                               int32_t id,
                               wl_fixed_t x,
                               wl_fixed_t y) {
  struct sl_host_touch* host =
      static_cast<sl_host_touch*>(wl_touch_get_user_data(touch));
  struct sl_host_surface* host_surface =
      surface ? static_cast<sl_host_surface*>(wl_surface_get_user_data(surface))
              : NULL;
  double scale = host->seat->ctx->scale;

  if (!host_surface)
    return;

  if (host_surface->resource != host->focus_resource) {
    wl_list_remove(&host->focus_resource_listener.link);
    wl_list_init(&host->focus_resource_listener.link);
    host->focus_resource = host_surface->resource;
    wl_resource_add_destroy_listener(host_surface->resource,
                                     &host->focus_resource_listener);
  }

  if (host->seat->ctx->xwayland) {
    // Make sure focus surface is on top before sending down event.
    sl_restack_windows(host->seat->ctx,
                       wl_resource_get_id(host_surface->resource));
    sl_roundtrip(host->seat->ctx);
  }

  wl_touch_send_down(host->resource, serial, time, host_surface->resource, id,
                     x * scale, y * scale);

  if (host->focus_resource)
    sl_set_last_event_serial(host->focus_resource, serial);
  host->seat->last_serial = serial;
}  // NOLINT(whitespace/indent)

static void sl_host_touch_up(void* data,
                             struct wl_touch* touch,
                             uint32_t serial,
                             uint32_t time,
                             int32_t id) {
  struct sl_host_touch* host =
      static_cast<sl_host_touch*>(wl_touch_get_user_data(touch));

  wl_list_remove(&host->focus_resource_listener.link);
  wl_list_init(&host->focus_resource_listener.link);
  host->focus_resource = NULL;

  wl_touch_send_up(host->resource, serial, time, id);

  if (host->focus_resource)
    sl_set_last_event_serial(host->focus_resource, serial);
  host->seat->last_serial = serial;
}

static void sl_host_touch_motion(void* data,
                                 struct wl_touch* touch,
                                 uint32_t time,
                                 int32_t id,
                                 wl_fixed_t x,
                                 wl_fixed_t y) {
  struct sl_host_touch* host =
      static_cast<sl_host_touch*>(wl_touch_get_user_data(touch));
  double scale = host->seat->ctx->scale;

  wl_touch_send_motion(host->resource, time, id, x * scale, y * scale);
}

static void sl_host_touch_frame(void* data, struct wl_touch* touch) {
  struct sl_host_touch* host =
      static_cast<sl_host_touch*>(wl_touch_get_user_data(touch));

  wl_touch_send_frame(host->resource);
}

static void sl_host_touch_cancel(void* data, struct wl_touch* touch) {
  struct sl_host_touch* host =
      static_cast<sl_host_touch*>(wl_touch_get_user_data(touch));

  wl_touch_send_cancel(host->resource);
}

static const struct wl_touch_listener sl_touch_listener = {
    sl_host_touch_down, sl_host_touch_up, sl_host_touch_motion,
    sl_host_touch_frame, sl_host_touch_cancel};

static void sl_destroy_host_pointer(struct wl_resource* resource) {
  struct sl_host_pointer* host =
      static_cast<sl_host_pointer*>(wl_resource_get_user_data(resource));

  if (wl_pointer_get_version(host->proxy) >= WL_POINTER_RELEASE_SINCE_VERSION) {
    wl_pointer_release(host->proxy);
  } else {
    wl_pointer_destroy(host->proxy);
  }
  wl_list_remove(&host->focus_resource_listener.link);
  wl_resource_set_user_data(resource, NULL);
  free(host);
}

static void sl_pointer_focus_resource_destroyed(struct wl_listener* listener,
                                                void* data) {
  struct sl_host_pointer* host;

  host = wl_container_of(listener, host, focus_resource_listener);
  sl_pointer_set_focus(host, host->focus_serial, NULL, 0, 0);
}

static void sl_host_seat_get_host_pointer(struct wl_client* client,
                                          struct wl_resource* resource,
                                          uint32_t id) {
  struct sl_host_seat* host =
      static_cast<sl_host_seat*>(wl_resource_get_user_data(resource));
  struct sl_host_pointer* host_pointer =
      static_cast<sl_host_pointer*>(malloc(sizeof(*host_pointer)));
  assert(host_pointer);

  host_pointer->seat = host->seat;
  host_pointer->resource = wl_resource_create(
      client, &wl_pointer_interface, wl_resource_get_version(resource), id);
  wl_resource_set_implementation(host_pointer->resource,
                                 &sl_pointer_implementation, host_pointer,
                                 sl_destroy_host_pointer);
  host_pointer->proxy = wl_seat_get_pointer(host->proxy);
  wl_pointer_set_user_data(host_pointer->proxy, host_pointer);
  wl_pointer_add_listener(host_pointer->proxy, &sl_pointer_listener,
                          host_pointer);
  wl_list_init(&host_pointer->focus_resource_listener.link);
  host_pointer->focus_resource_listener.notify =
      sl_pointer_focus_resource_destroyed;
  host_pointer->focus_resource = NULL;
  host_pointer->focus_serial = 0;
  host_pointer->time = 0;
  host_pointer->axis_delta[0] = wl_fixed_from_int(0);
  host_pointer->axis_delta[1] = wl_fixed_from_int(0);
  host_pointer->axis_discrete[0] = 0;
  host_pointer->axis_discrete[1] = 0;
}

static void sl_destroy_host_keyboard(struct wl_resource* resource) {
  struct sl_host_keyboard* host =
      static_cast<sl_host_keyboard*>(wl_resource_get_user_data(resource));

  if (host->extended_keyboard_proxy)
    zcr_extended_keyboard_v1_destroy(host->extended_keyboard_proxy);

  wl_array_release(&host->pressed_keys);
  if (host->keymap)
    xkb_keymap_unref(host->keymap);
  if (host->state)
    xkb_state_unref(host->state);

  if (wl_keyboard_get_version(host->proxy) >=
      WL_KEYBOARD_RELEASE_SINCE_VERSION) {
    wl_keyboard_release(host->proxy);
  } else {
    wl_keyboard_destroy(host->proxy);
  }

  wl_list_remove(&host->focus_resource_listener.link);
  wl_resource_set_user_data(resource, NULL);
  free(host);
}

static void sl_keyboard_focus_resource_destroyed(struct wl_listener* listener,
                                                 void* data) {
  struct sl_host_keyboard* host;
  struct wl_array array;

  host = wl_container_of(listener, host, focus_resource_listener);
  wl_array_init(&array);
  sl_keyboard_set_focus(host, host->focus_serial, NULL, &array);
}

static void sl_host_seat_get_host_keyboard(struct wl_client* client,
                                           struct wl_resource* resource,
                                           uint32_t id) {
  struct sl_host_seat* host =
      static_cast<sl_host_seat*>(wl_resource_get_user_data(resource));
  struct sl_host_keyboard* host_keyboard =
      static_cast<sl_host_keyboard*>(malloc(sizeof(*host_keyboard)));
  assert(host_keyboard);

  host_keyboard->seat = host->seat;
  host_keyboard->resource = wl_resource_create(
      client, &wl_keyboard_interface, wl_resource_get_version(resource), id);
  wl_resource_set_implementation(host_keyboard->resource,
                                 &sl_keyboard_implementation, host_keyboard,
                                 sl_destroy_host_keyboard);
  host_keyboard->proxy = wl_seat_get_keyboard(host->proxy);
  wl_keyboard_set_user_data(host_keyboard->proxy, host_keyboard);
  wl_keyboard_add_listener(host_keyboard->proxy, &sl_keyboard_listener,
                           host_keyboard);
  wl_list_init(&host_keyboard->focus_resource_listener.link);
  host_keyboard->focus_resource_listener.notify =
      sl_keyboard_focus_resource_destroyed;
  host_keyboard->focus_resource = NULL;
  host_keyboard->focus_serial = 0;
  host_keyboard->keymap = NULL;
  host_keyboard->state = NULL;
  host_keyboard->control_mask = 0;
  host_keyboard->alt_mask = 0;
  host_keyboard->shift_mask = 0;
  host_keyboard->modifiers = 0;
  wl_array_init(&host_keyboard->pressed_keys);

  if (host->seat->ctx->keyboard_extension) {
    host_keyboard->extended_keyboard_proxy =
        zcr_keyboard_extension_v1_get_extended_keyboard(
            host->seat->ctx->keyboard_extension->internal,
            host_keyboard->proxy);
  } else {
    host_keyboard->extended_keyboard_proxy = NULL;
  }
}

static void sl_destroy_host_touch(struct wl_resource* resource) {
  struct sl_host_touch* host =
      static_cast<sl_host_touch*>(wl_resource_get_user_data(resource));

  if (wl_touch_get_version(host->proxy) >= WL_TOUCH_RELEASE_SINCE_VERSION) {
    wl_touch_release(host->proxy);
  } else {
    wl_touch_destroy(host->proxy);
  }
  wl_resource_set_user_data(resource, NULL);
  free(host);
}

static void sl_touch_focus_resource_destroyed(struct wl_listener* listener,
                                              void* data) {
  struct sl_host_touch* host;

  host = wl_container_of(listener, host, focus_resource_listener);
  wl_list_remove(&host->focus_resource_listener.link);
  wl_list_init(&host->focus_resource_listener.link);
  host->focus_resource = NULL;
}

static void sl_host_seat_get_host_touch(struct wl_client* client,
                                        struct wl_resource* resource,
                                        uint32_t id) {
  struct sl_host_seat* host =
      static_cast<sl_host_seat*>(wl_resource_get_user_data(resource));
  struct sl_host_touch* host_touch =
      static_cast<sl_host_touch*>(malloc(sizeof(*host_touch)));
  assert(host_touch);

  host_touch->seat = host->seat;
  host_touch->resource = wl_resource_create(
      client, &wl_touch_interface, wl_resource_get_version(resource), id);
  wl_resource_set_implementation(host_touch->resource, &sl_touch_implementation,
                                 host_touch, sl_destroy_host_touch);
  host_touch->proxy = wl_seat_get_touch(host->proxy);
  wl_touch_set_user_data(host_touch->proxy, host_touch);
  wl_touch_add_listener(host_touch->proxy, &sl_touch_listener, host_touch);
  wl_list_init(&host_touch->focus_resource_listener.link);
  host_touch->focus_resource_listener.notify =
      sl_touch_focus_resource_destroyed;
  host_touch->focus_resource = NULL;
}

static void sl_host_seat_release(struct wl_client* client,
                                 struct wl_resource* resource) {
  struct sl_host_seat* host =
      static_cast<sl_host_seat*>(wl_resource_get_user_data(resource));

  wl_seat_release(host->proxy);
}

static const struct wl_seat_interface sl_seat_implementation = {
    sl_host_seat_get_host_pointer, sl_host_seat_get_host_keyboard,
    sl_host_seat_get_host_touch, sl_host_seat_release};

static void sl_seat_capabilities(void* data,
                                 struct wl_seat* seat,
                                 uint32_t capabilities) {
  struct sl_host_seat* host =
      static_cast<sl_host_seat*>(wl_seat_get_user_data(seat));

  wl_seat_send_capabilities(host->resource, capabilities);
}

static void sl_seat_name(void* data, struct wl_seat* seat, const char* name) {
  struct sl_host_seat* host =
      static_cast<sl_host_seat*>(wl_seat_get_user_data(seat));

  if (wl_resource_get_version(host->resource) >= WL_SEAT_NAME_SINCE_VERSION)
    wl_seat_send_name(host->resource, name);
}

static const struct wl_seat_listener sl_seat_listener = {sl_seat_capabilities,
                                                         sl_seat_name};

static void sl_destroy_host_seat(struct wl_resource* resource) {
  struct sl_host_seat* host =
      static_cast<sl_host_seat*>(wl_resource_get_user_data(resource));

  sl_host_seat_removed(host);

  if (wl_seat_get_version(host->proxy) >= WL_SEAT_RELEASE_SINCE_VERSION)
    wl_seat_release(host->proxy);
  else
    wl_seat_destroy(host->proxy);
  wl_resource_set_user_data(resource, NULL);
  free(host);
}

static void sl_bind_host_seat(struct wl_client* client,
                              void* data,
                              uint32_t version,
                              uint32_t id) {
  struct sl_seat* seat = (struct sl_seat*)data;
  struct sl_host_seat* host = static_cast<sl_host_seat*>(malloc(sizeof(*host)));
  assert(host);
  host->seat = seat;
  host->resource = wl_resource_create(client, &wl_seat_interface,
                                      MIN(version, seat->version), id);
  wl_resource_set_implementation(host->resource, &sl_seat_implementation, host,
                                 sl_destroy_host_seat);
  host->proxy = static_cast<wl_seat*>(wl_registry_bind(
      wl_display_get_registry(seat->ctx->display), seat->id, &wl_seat_interface,
      wl_resource_get_version(host->resource)));
  wl_seat_set_user_data(host->proxy, host);
  wl_seat_add_listener(host->proxy, &sl_seat_listener, host);

  sl_host_seat_added(host);
}

struct sl_global* sl_seat_global_create(struct sl_seat* seat) {
  return sl_global_create(seat->ctx, &wl_seat_interface, seat->version, seat,
                          sl_bind_host_seat);
}