#include <cjson/cJSON.h>
#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <linux/input-event-codes.h>
#include <linux/uinput.h>
#include <msgpack.h>
#include <msgpack/object.h>
#include <msgpack/pack.h>
#include <msgpack/unpack.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/param.h>
#include <sys/time.h>
#include <unistd.h>
#include <wayland-client-protocol.h>
#include <wayland-util.h>

#include "glib-object.h"
#include "glib.h"
#include "gst/gstbuffer.h"
#include "gst/gstinfo.h"
#include "gst/gstobject.h"
#include "gst/gstparamspecs.h"
#include "gst/gstvalue.h"
#include "gst/video/video-format.h"
#include "gstwestonimagesrc.h"

// Gtreamer plugin related defines and declarations
GST_DEBUG_CATEGORY_STATIC(gst_westonimagesrc_debug);
#define GST_CAT_DEFAULT gst_westonimagesrc_debug

static GstStaticPadTemplate src_template = GST_STATIC_PAD_TEMPLATE("src", GST_PAD_SRC, GST_PAD_ALWAYS,
                                                                   GST_STATIC_CAPS("video/x-raw, "
                                                                                   "format = (string) { BGRA, bgra }, "
                                                                                   "width = (int) [ 1, 1280 ], "
                                                                                   "height = (int) [ 1, 800 ], "
                                                                                   "framerate = (fraction) [ 1/1, 30/1 ]"));

enum {
  PROP_0,
  N_PROPERTIES,
};

enum {
  RCONTROL_EVENT_TYPE_UNDEFINED = 0,
  RCONTROL_EVENT_TYPE_MOUSE_BTN_PRESS = 2,
  RCONTROL_EVENT_TYPE_MOUSE_BTN_RELEASE = 3,
  RCONTROL_EVENT_TYPE_MOUSE_MOVE = 5,
  RCONTROL_EVENT_TYPE_MOUSE_WHEEL = 31,
  N_EVENT_TYPES,
};

enum {
  RCONTROL_MOUSE_BTN_UNDEFINED = 0,
  RCONTROL_MOUSE_BTN_LEFT = 1,
  RCONTROL_MOUSE_BTN_RIGHT = 2,
  RCONTROL_MOUSE_BTN_MID = 4,
  N_MOUSE_BTN,
};

// Gstreamer related
static gboolean gst_westonimagesrc_start(GstBaseSrc *basesrc);
static gboolean gst_westonimagesrc_stop(GstBaseSrc *basesrc);
static GstFlowReturn gst_westonimagesrc_create(GstBaseSrc *basesrc, guint64 offset, guint size, GstBuffer **buf);
static gboolean gst_westonimagesrc_unlock(GstBaseSrc *basesrc);
static gboolean gst_westonimagesrc_unlock_stop(GstBaseSrc *basesrc);

static void gst_westonimagesrc_class_init(GstWestonImageSrcClass *klass);
static void gst_westonimagesrc_init(GstWestonImageSrc *westonimagesrc);
static void gst_westonimagesrc_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec);
static void gst_westonimagesrc_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec);
static gboolean gst_westonimagesrc_set_caps(GstBaseSrc *src, GstCaps *caps);

G_DEFINE_TYPE(GstWestonImageSrc, gst_westonimagesrc, GST_TYPE_BASE_SRC);

// Weston related
static void weston_display_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int width, int height, int refresh);
static void weston_display_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, int transform);
static void weston_screenshot_done(void *data, struct weston_screenshooter *screenshooter);
static void weston_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version);
static void weston_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name);

static void weston_handle_global_remove(void *data, struct wl_registry *registry, uint32_t name) { /* XXX: unimplemented */ }
static struct wl_buffer *weston_screenshot_create_shm_buffer(int width, int height, void **data_out, struct wl_shm *shm);
static int weston_screenshot_set_buffer_size(struct buffer_size *buff_size, struct wl_list *output_list);

static const struct wl_output_listener output_listener = {weston_display_handle_geometry, weston_display_handle_mode};
static const struct weston_screenshooter_listener screenshooter_listener = {weston_screenshot_done};
static const struct wl_registry_listener registry_listener = {weston_handle_global, weston_handle_global_remove};

// Remote control
static void rcontrol_init(GstWestonImageSrc *westonimagesrc);
static void rcontrol_init_uinput(GstWestonImageSrc *westonimagesrc);
static void rcontrol_init_server(GstWestonImageSrc *westonimagesrc);
static gpointer rcontrol_listener_thread(gpointer data);
static void rcontrol_destroy(GstWestonImageSrc *westonimagesrc);
static void rcontrol_emit(GstWestonImageSrc *westonimagesrc, int type, int code, int value);
static void rcontrol_handle_compound(GstWestonImageSrc *westonimagesrc, msgpack_object obj);
static int rcontrol_get_event_type(GstWestonImageSrc *westonimagesrc, msgpack_object obj);
static float rcontrol_get_mouse_pos(GstWestonImageSrc *westonimagesrc, msgpack_object obj, const char *key);
static float rcontrol_get_mouse_btn(GstWestonImageSrc *westonimagesrc, msgpack_object obj);

static void rcontrol_emit(GstWestonImageSrc *westonimagesrc, int type, int code, int value) {
  struct input_event ev;
  memset(&ev, 0, sizeof(ev));
  gettimeofday(&ev.time, NULL);
  ev.type = type;
  ev.code = code;
  ev.value = value;

  if (write(westonimagesrc->uinput_fd, &ev, sizeof(ev)) < 0) {
    GST_WARNING_OBJECT(westonimagesrc, "write() input_event %i:%i:%i:%i failed", westonimagesrc->uinput_fd, type, code, value);
  }
}

static void rcontrol_init(GstWestonImageSrc *westonimagesrc) {
  rcontrol_init_uinput(westonimagesrc);
  rcontrol_init_server(westonimagesrc);
}

static int rcontrol_get_event_type(GstWestonImageSrc *westonimagesrc, msgpack_object obj) {
  for (uint32_t i = 0; i < obj.via.map.size; i++) {
    msgpack_object_kv kv = obj.via.map.ptr[i];
    if (kv.key.type == MSGPACK_OBJECT_STR) {
      if (!strncmp(kv.key.via.str.ptr, "t", kv.key.via.str.size)) {
        return kv.val.via.u64;
      }
    }
  }

  return RCONTROL_EVENT_TYPE_UNDEFINED;
}

static float rcontrol_get_mouse_pos(GstWestonImageSrc *westonimagesrc, msgpack_object obj, const char *key) {
  for (uint32_t i = 0; i < obj.via.map.size; i++) {
    msgpack_object_kv kv = obj.via.map.ptr[i];
    if (kv.key.type == MSGPACK_OBJECT_STR) {
      if (!strncmp(kv.key.via.str.ptr, key, kv.key.via.str.size)) {
        return (float)kv.val.via.f64;
      }
    }
  }

  return -1.f;
}

static float rcontrol_get_mouse_btn(GstWestonImageSrc *westonimagesrc, msgpack_object obj) {
  for (uint32_t i = 0; i < obj.via.map.size; i++) {
    msgpack_object_kv kv = obj.via.map.ptr[i];
    if (kv.key.type == MSGPACK_OBJECT_STR) {
      if (!strncmp(kv.key.via.str.ptr, "b", kv.key.via.str.size)) {
        return kv.val.via.u64;
      }
    }
  }

  return RCONTROL_MOUSE_BTN_UNDEFINED;
}

static void rcontrol_handle_compound(GstWestonImageSrc *westonimagesrc, msgpack_object obj) {
  switch (obj.type) {
  case MSGPACK_OBJECT_MAP: {
    int event_type;
    switch (event_type = rcontrol_get_event_type(westonimagesrc, obj)) {
    case RCONTROL_EVENT_TYPE_MOUSE_MOVE: {
      float x = rcontrol_get_mouse_pos(westonimagesrc, obj, "x");
      float y = rcontrol_get_mouse_pos(westonimagesrc, obj, "y");

      if (x >= 0.f && y >= 0.f) {
        rcontrol_emit(westonimagesrc, EV_ABS, ABS_X, buff_size.width * x);
        rcontrol_emit(westonimagesrc, EV_ABS, ABS_Y, buff_size.height * y);
        rcontrol_emit(westonimagesrc, EV_SYN, SYN_REPORT, 0);
      }
    } break;

    case RCONTROL_EVENT_TYPE_MOUSE_BTN_PRESS: {
      int btn;
      switch (btn = rcontrol_get_mouse_btn(westonimagesrc, obj)) {
      case RCONTROL_MOUSE_BTN_LEFT: {
        rcontrol_emit(westonimagesrc, EV_KEY, BTN_LEFT, 1);
        rcontrol_emit(westonimagesrc, EV_SYN, SYN_REPORT, 0);
      } break;

      case RCONTROL_MOUSE_BTN_RIGHT: {
        rcontrol_emit(westonimagesrc, EV_KEY, BTN_RIGHT, 1);
        rcontrol_emit(westonimagesrc, EV_SYN, SYN_REPORT, 0);
      } break;

      case RCONTROL_MOUSE_BTN_MID: {
        rcontrol_emit(westonimagesrc, EV_KEY, BTN_MIDDLE, 1);
        rcontrol_emit(westonimagesrc, EV_SYN, SYN_REPORT, 0);
      } break;
      default:
        break;
      }
    } break;

    case RCONTROL_EVENT_TYPE_MOUSE_BTN_RELEASE: {
      int btn;
      switch (btn = rcontrol_get_mouse_btn(westonimagesrc, obj)) {
      case RCONTROL_MOUSE_BTN_LEFT: {
        rcontrol_emit(westonimagesrc, EV_KEY, BTN_LEFT, 0);
        rcontrol_emit(westonimagesrc, EV_SYN, SYN_REPORT, 0);
      } break;

      case RCONTROL_MOUSE_BTN_RIGHT: {
        rcontrol_emit(westonimagesrc, EV_KEY, BTN_RIGHT, 0);
        rcontrol_emit(westonimagesrc, EV_SYN, SYN_REPORT, 0);
      } break;

      case RCONTROL_MOUSE_BTN_MID: {
        rcontrol_emit(westonimagesrc, EV_KEY, BTN_MIDDLE, 0);
        rcontrol_emit(westonimagesrc, EV_SYN, SYN_REPORT, 0);
      } break;
      default:
        break;
      }
    } break;

    case RCONTROL_EVENT_TYPE_MOUSE_WHEEL: {
      float y = rcontrol_get_mouse_pos(westonimagesrc, obj, "y");
      
      rcontrol_emit(westonimagesrc, EV_REL, REL_WHEEL, y);
      rcontrol_emit(westonimagesrc, EV_SYN, SYN_REPORT, 0);
    } break;

    case RCONTROL_EVENT_TYPE_UNDEFINED:
    default:
      break;
    }

    for (uint32_t i = 0; i < obj.via.map.size; i++) {
      msgpack_object_kv kv = obj.via.map.ptr[i];
      if (kv.key.type == MSGPACK_OBJECT_STR) {
        switch (kv.val.type) {
        case MSGPACK_OBJECT_STR: {
          GST_INFO_OBJECT(westonimagesrc, "%.*s: %.*s", kv.key.via.str.size, kv.key.via.str.ptr, kv.val.via.str.size, kv.val.via.str.ptr);
        } break;

        case MSGPACK_OBJECT_POSITIVE_INTEGER: {
          GST_INFO_OBJECT(westonimagesrc, "%.*s:  %llu", kv.key.via.str.size, kv.key.via.str.ptr, (unsigned long long)kv.val.via.u64);
        } break;

        case MSGPACK_OBJECT_NEGATIVE_INTEGER: {
          GST_INFO_OBJECT(westonimagesrc, "%.*s: %lld", kv.key.via.str.size, kv.key.via.str.ptr, (long long)kv.val.via.i64);
        } break;

        case MSGPACK_OBJECT_FLOAT:
        case MSGPACK_OBJECT_FLOAT32: {
          GST_INFO_OBJECT(westonimagesrc, "%.*s: %lf", kv.key.via.str.size, kv.key.via.str.ptr, (double)kv.val.via.f64);
        } break;

        case MSGPACK_OBJECT_BOOLEAN: {
          GST_INFO_OBJECT(westonimagesrc, "%.*s: %i", kv.key.via.str.size, kv.key.via.str.ptr, (gboolean)kv.val.via.boolean);
        } break;

        case MSGPACK_OBJECT_ARRAY: {
          GST_INFO_OBJECT(westonimagesrc, "%.*s: (array)", kv.key.via.str.size, kv.key.via.str.ptr);
          rcontrol_handle_compound(westonimagesrc, kv.val);
        } break;

        case MSGPACK_OBJECT_MAP: {
          GST_INFO_OBJECT(westonimagesrc, "%.*s: (object)", kv.key.via.str.size, kv.key.via.str.ptr);
          rcontrol_handle_compound(westonimagesrc, kv.val);
        } break;

        default:
          GST_INFO_OBJECT(westonimagesrc, "%.*s: (unknown)", kv.key.via.str.size, kv.key.via.str.ptr);
        }
      }
    }

    break;

  case MSGPACK_OBJECT_ARRAY: {
    for (uint32_t i = 0; i < obj.via.map.size; i++) {
      msgpack_object o = obj.via.array.ptr[i];
      switch (o.type) {
      case MSGPACK_OBJECT_STR: {
        GST_INFO_OBJECT(westonimagesrc, "%i: %.*s", i, o.via.str.size, o.via.str.ptr);
      } break;

      case MSGPACK_OBJECT_POSITIVE_INTEGER: {
        GST_INFO_OBJECT(westonimagesrc, "%i:  %llu", i, (unsigned long long)o.via.u64);
      } break;

      case MSGPACK_OBJECT_NEGATIVE_INTEGER: {
        GST_INFO_OBJECT(westonimagesrc, "%i: %lld", i, (long long)o.via.i64);
      } break;

      case MSGPACK_OBJECT_FLOAT:
      case MSGPACK_OBJECT_FLOAT32: {
        GST_INFO_OBJECT(westonimagesrc, "%i: %lf", i, (double)o.via.f64);
      } break;

      case MSGPACK_OBJECT_BOOLEAN: {
        GST_INFO_OBJECT(westonimagesrc, "%i: %i", i, (gboolean)o.via.boolean);
      } break;

      case MSGPACK_OBJECT_ARRAY: {
        GST_INFO_OBJECT(westonimagesrc, "%i: (array)", i);
        rcontrol_handle_compound(westonimagesrc, o);
      } break;

      case MSGPACK_OBJECT_MAP: {
        GST_INFO_OBJECT(westonimagesrc, "%i: (object)", i);
        rcontrol_handle_compound(westonimagesrc, o);
      } break;

      default:
        GST_INFO_OBJECT(westonimagesrc, "%i: (unknown)", i);
      }
    }
    break;

  default:
    break;
  }
  }
  }
}

static gpointer rcontrol_listener_thread(gpointer data) {
  const uint16_t port = 7755u;
  GstWestonImageSrc *westonimagesrc = data;
  g_mutex_lock(&westonimagesrc->lock);

  westonimagesrc->udp_socket_fd = socket(AF_INET6, SOCK_DGRAM, 0);
  if (westonimagesrc->udp_socket_fd < 0) {
    GST_ERROR_OBJECT(westonimagesrc, "socket() UDP socket creation failed: %s", strerror(errno));
    return NULL;
  }

  /* ВАЖНО: разрешаем dual-stack (IPv4 + IPv6) */
  int off = 0;
  if (setsockopt(westonimagesrc->udp_socket_fd, IPPROTO_IPV6, IPV6_V6ONLY, &off, sizeof(off)) < 0) {
    GST_WARNING_OBJECT(westonimagesrc, "setsockopt() IPV6_V6ONLY failed: %s", strerror(errno));
  }

  struct sockaddr_in6 addr;
  memset(&addr, 0, sizeof(addr));
  addr.sin6_family = AF_INET6;
  addr.sin6_port = htons(port);
  addr.sin6_addr = in6addr_any; /* :: */

  if (bind(westonimagesrc->udp_socket_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
    GST_ERROR_OBJECT(westonimagesrc, "bind() UDP socket binding failed: %s", strerror(errno));
    close(westonimagesrc->udp_socket_fd);
    return NULL;
  }

  g_mutex_unlock(&westonimagesrc->lock);
  GST_INFO_OBJECT(westonimagesrc, "UDP listener started on port %d\n", port);

  char msgpack_buf[1024u], msg_buf[1024u];
  char addrstr[INET6_ADDRSTRLEN];
  int src_port = 0;

  msgpack_zone mempool;
  msgpack_zone_init(&mempool, sizeof(msgpack_buf));

  while (TRUE) {
    struct sockaddr_in src;
    socklen_t srclen = sizeof(src);
    ssize_t len = recvfrom(westonimagesrc->udp_socket_fd, msgpack_buf, sizeof(msgpack_buf) - 1, 0, (struct sockaddr *)&src, &srclen);

    if (len < 0) {
      GST_WARNING_OBJECT(westonimagesrc, "recvfrom()  failed");
      continue;
    }

    if (src.sin_family == AF_INET6) {

      struct sockaddr_in6 *s6 = (struct sockaddr_in6 *)&src;
      inet_ntop(AF_INET6, &s6->sin6_addr, addrstr, sizeof(addrstr));
      src_port = ntohs(s6->sin6_port);
    } else if (src.sin_family == AF_INET) {

      struct sockaddr_in *s4 = (struct sockaddr_in *)&src;
      inet_ntop(AF_INET, &s4->sin_addr, addrstr, sizeof(addrstr));
      src_port = ntohs(s4->sin_port);
    } else {

      strcpy(addrstr, "unknown");
    }

    msgpack_unpacked msg;
    msgpack_unpacked_init(&msg);
    gboolean success = msgpack_unpack_next(&msg, msgpack_buf, sizeof(msgpack_buf), NULL);
    if (!success) {
      GST_WARNING_OBJECT(westonimagesrc, "Msgpack unpacking failed");
      continue;
    }

    if (msg.data.type != MSGPACK_OBJECT_MAP) {
      GST_WARNING_OBJECT(westonimagesrc, "Msgpack expected type is MAP");
      continue;
    }

    GST_INFO_OBJECT(westonimagesrc, "[UDP %s:%d]: received MAP of size: %u", addrstr, src_port, msg.data.via.map.size);
    rcontrol_handle_compound(westonimagesrc, msg.data);
  }

  close(westonimagesrc->udp_socket_fd);
  return NULL;
}

static void rcontrol_init_server(GstWestonImageSrc *westonimagesrc) {
  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->listener_thread = g_thread_new("UDP listener thread", rcontrol_listener_thread, westonimagesrc);
  g_mutex_unlock(&westonimagesrc->lock);
}

static void rcontrol_init_uinput(GstWestonImageSrc *westonimagesrc) {
  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->uinput_fd = open("/dev/uinput", O_WRONLY | O_NONBLOCK);
  if (westonimagesrc->uinput_fd < 0) {
    GST_ERROR_OBJECT(westonimagesrc, "open() /dev/uinput failed");
    return;
  }

  // Init keyboard
  {
    ioctl(westonimagesrc->uinput_fd, UI_SET_EVBIT, EV_KEY);

    for (int key = KEY_ESC; key <= KEY_MICMUTE; key++) {
      ioctl(westonimagesrc->uinput_fd, UI_SET_KEYBIT, key);
    }
  }

  // Init mouse
  {
    // Mouse buttons
    ioctl(westonimagesrc->uinput_fd, UI_SET_KEYBIT, BTN_LEFT);
    ioctl(westonimagesrc->uinput_fd, UI_SET_KEYBIT, BTN_RIGHT);
    ioctl(westonimagesrc->uinput_fd, UI_SET_KEYBIT, BTN_MIDDLE);

    // ABS bits
    ioctl(westonimagesrc->uinput_fd, UI_SET_EVBIT, EV_ABS);
    ioctl(westonimagesrc->uinput_fd, UI_SET_ABSBIT, ABS_X);
    ioctl(westonimagesrc->uinput_fd, UI_SET_ABSBIT, ABS_Y);

    ioctl(westonimagesrc->uinput_fd, UI_SET_EVBIT, EV_REL);
    ioctl(westonimagesrc->uinput_fd, UI_SET_RELBIT, REL_X);
    ioctl(westonimagesrc->uinput_fd, UI_SET_RELBIT, REL_Y);
    ioctl(westonimagesrc->uinput_fd, UI_SET_RELBIT, REL_WHEEL);
    ioctl(westonimagesrc->uinput_fd, UI_SET_RELBIT, REL_HWHEEL);

    struct uinput_abs_setup abs_x = {
        .code = ABS_X,
        .absinfo =
            {
                .minimum = 0,
                .maximum = buff_size.width,
                .resolution = 1,
            },
    };

    struct uinput_abs_setup abs_y = {
        .code = ABS_Y,
        .absinfo =
            {
                .minimum = 0,
                .maximum = buff_size.height,
                .resolution = 1,
            },
    };

    ioctl(westonimagesrc->uinput_fd, UI_ABS_SETUP, &abs_x);
    ioctl(westonimagesrc->uinput_fd, UI_ABS_SETUP, &abs_y);
  }

  // Init device
  struct uinput_setup usetup;
  memset(&usetup, 0, sizeof(usetup));

  snprintf(usetup.name, UINPUT_MAX_NAME_SIZE, "Virtual Keyboard + Mouse");
  usetup.id.bustype = BUS_USB;
  usetup.id.vendor = 0x7777;
  usetup.id.product = 0x8888;
  usetup.id.version = 1;

  ioctl(westonimagesrc->uinput_fd, UI_SET_EVBIT, EV_SYN);
  if (ioctl(westonimagesrc->uinput_fd, UI_DEV_SETUP, &usetup) < 0) {
    GST_ERROR_OBJECT(westonimagesrc, "ioctl() UI_DEV_SETUP failed");
    return;
  }

  if (ioctl(westonimagesrc->uinput_fd, UI_DEV_CREATE) < 0) {
    GST_ERROR_OBJECT(westonimagesrc, "ioctl() UI_DEV_CREATE failed");
    return;
  }

  sleep(1);
  g_mutex_unlock(&westonimagesrc->lock);
}

static void rcontrol_destroy(GstWestonImageSrc *westonimagesrc) {
  ioctl(westonimagesrc->uinput_fd, UI_DEV_DESTROY);
  close(westonimagesrc->uinput_fd);
}

static int weston_screenshot_set_buffer_size(struct buffer_size *buff_size, struct wl_list *output_list) {
  struct screenshooter_output *output;
  buff_size->min_x = buff_size->min_y = INT_MAX;
  buff_size->max_x = buff_size->max_y = INT_MIN;
  int position = 0;

  wl_list_for_each_reverse(output, output_list, link) {
    output->offset_x = position;
    position += output->width;
  }

  wl_list_for_each(output, output_list, link) {
    buff_size->min_x = MIN(buff_size->min_x, output->offset_x);
    buff_size->min_y = MIN(buff_size->min_y, output->offset_y);
    buff_size->max_x = MAX(buff_size->max_x, output->offset_x + output->width);
    buff_size->max_y = MAX(buff_size->max_y, output->offset_y + output->height);
  }

  if (buff_size->max_x <= buff_size->min_x || buff_size->max_y <= buff_size->min_y)
    return -1;

  buff_size->width = buff_size->max_x - buff_size->min_x;
  buff_size->height = buff_size->max_y - buff_size->min_y;

  return 0;
}

static struct wl_buffer *weston_screenshot_create_shm_buffer(int width, int height, void **data_out, struct wl_shm *shm) {
  struct wl_shm_pool *pool;
  struct wl_buffer *buffer;
  int fd, size, stride;
  void *data;

  stride = width * 4;
  size = stride * height;

  fd = os_create_anonymous_file(size);
  if (fd < 0) {
    fprintf(stderr, "creating a buffer file for %d B failed: %s\n", size, strerror(errno));
    return NULL;
  }

  data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
  if (data == MAP_FAILED) {
    fprintf(stderr, "mmap failed: %s\n", strerror(errno));
    close(fd);
    return NULL;
  }

  pool = wl_shm_create_pool(shm, fd, size);
  close(fd);
  buffer = wl_shm_pool_create_buffer(pool, 0, width, height, stride, WL_SHM_FORMAT_XRGB8888);
  wl_shm_pool_destroy(pool);

  *data_out = data;

  return buffer;
}

static void weston_handle_global(void *data, struct wl_registry *registry, uint32_t name, const char *interface, uint32_t version) {
  static struct screenshooter_output *output;
  struct screenshooter_data *sh_data = data;

  if (strcmp(interface, "wl_output") == 0) {

    output = xmalloc(sizeof *output);
    output->output = wl_registry_bind(registry, name, &wl_output_interface, 1);
    wl_list_insert(&sh_data->output_list, &output->link);
    wl_output_add_listener(output->output, &output_listener, output);
  } else if (strcmp(interface, "wl_shm") == 0) {

    sh_data->shm = wl_registry_bind(registry, name, &wl_shm_interface, 1);
  } else if (strcmp(interface, "weston_screenshooter") == 0) {

    sh_data->screenshooter = wl_registry_bind(registry, name, &weston_screenshooter_interface, 1);
  }
}

static void weston_screenshot_done(void *data, struct weston_screenshooter *screenshooter) {
  struct screenshooter_data *sh_data = data;
  sh_data->buffer_copy_done = 1;
}

static void weston_display_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, int transform) {
  struct screenshooter_output *output;
  output = wl_output_get_user_data(wl_output);

  if (wl_output == output->output) {
    output->offset_x = x;
    output->offset_y = y;
  }
}

static void weston_display_handle_mode(void *data, struct wl_output *wl_output, uint32_t flags, int width, int height, int refresh) {
  struct screenshooter_output *output;
  output = wl_output_get_user_data(wl_output);

  if (wl_output == output->output && (flags & WL_OUTPUT_MODE_CURRENT)) {
    output->width = width;
    output->height = height;
  }
}

static void gst_westonimagesrc_class_init(GstWestonImageSrcClass *klass) {
  GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
  GstElementClass *gstelement_class = GST_ELEMENT_CLASS(klass);
  GstBaseSrcClass *gstbasesrc_class = GST_BASE_SRC_CLASS(klass);

  gobject_class->set_property = gst_westonimagesrc_set_property;
  gobject_class->get_property = gst_westonimagesrc_get_property;

  gstbasesrc_class->start = GST_DEBUG_FUNCPTR(gst_westonimagesrc_start);
  gstbasesrc_class->stop = GST_DEBUG_FUNCPTR(gst_westonimagesrc_stop);
  gstbasesrc_class->create = GST_DEBUG_FUNCPTR(gst_westonimagesrc_create);

  gstbasesrc_class->set_caps = GST_DEBUG_FUNCPTR(gst_westonimagesrc_set_caps);
  gstbasesrc_class->get_caps = NULL;
  gstbasesrc_class->negotiate = NULL;

  gstbasesrc_class->unlock = GST_DEBUG_FUNCPTR(gst_westonimagesrc_unlock);
  gstbasesrc_class->unlock_stop = GST_DEBUG_FUNCPTR(gst_westonimagesrc_unlock_stop);

  gst_element_class_set_static_metadata(gstelement_class, "Weston Image Source", "Source/Video", "Generates XRGB screenshots",
                                        "OlegShishlyannikov oleg.shishlyannikov@piklema.com");
  gst_element_class_add_static_pad_template(gstelement_class, &src_template);
  GST_DEBUG_CATEGORY_INIT(gst_westonimagesrc_debug, "westonimagesrc", 0, "Weston Image Source Plugin");
}

static void gst_westonimagesrc_init(GstWestonImageSrc *westonimagesrc) {
  gst_base_src_set_live(GST_BASE_SRC(westonimagesrc), TRUE);
  gst_base_src_set_format(GST_BASE_SRC(westonimagesrc), GST_FORMAT_TIME);
  gst_base_src_set_blocksize(GST_BASE_SRC(westonimagesrc), 0);

  westonimagesrc->running = FALSE;
  westonimagesrc->timeout_id = 0;
  westonimagesrc->offset = 0;
  westonimagesrc->framerate_n = 30;
  westonimagesrc->framerate_d = 1;

  g_mutex_init(&westonimagesrc->lock);
  g_cond_init(&westonimagesrc->cond);

  // Get current display
  display = wl_display_connect(NULL);
  if (display == NULL) {
    fprintf(stderr, "failed to create display: %s\n", strerror(errno));
  }

  wl_list_init(&sh_data.output_list);
  registry = wl_display_get_registry(display);
  wl_registry_add_listener(registry, &registry_listener, &sh_data);
  wl_display_dispatch(display);
  wl_display_roundtrip(display);

  if (sh_data.screenshooter == NULL) {
    fprintf(stderr, "display doesn't support screenshooter\n");
  }

  weston_screenshooter_add_listener(sh_data.screenshooter, &screenshooter_listener, &sh_data);
  weston_screenshot_set_buffer_size(&buff_size, &sh_data.output_list);

  wl_list_for_each(output, &sh_data.output_list, link) {
    GST_INFO_OBJECT(westonimagesrc, "Creating shared mem buffer ...");
    output->buffer = weston_screenshot_create_shm_buffer(output->width, output->height, &output->data, sh_data.shm);
  }

  rcontrol_init(westonimagesrc);
}

static gboolean gst_westonimagesrc_set_caps(GstBaseSrc *basesrc, GstCaps *caps) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);
  GstStructure *s;
  const gchar *fmt;

  GST_INFO_OBJECT(westonimagesrc, "set_caps called: %" GST_PTR_FORMAT, caps);
  s = gst_caps_get_structure(caps, 0);

  gst_structure_get_int(s, "width", &westonimagesrc->width);
  gst_structure_get_int(s, "height", &westonimagesrc->height);
  gst_structure_get_fraction(s, "framerate", &westonimagesrc->framerate_n, &westonimagesrc->framerate_d);

  fmt = gst_structure_get_string(s, "format");
  if (!fmt)
    return FALSE;

  westonimagesrc->format = gst_video_format_from_string(fmt);
  GST_INFO_OBJECT(westonimagesrc, "Caps accepted: %s %dx%d @ %d/%d", fmt, westonimagesrc->width, westonimagesrc->height, westonimagesrc->framerate_n, westonimagesrc->framerate_d);

  return TRUE;
}

static void gst_westonimagesrc_set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(object);
  GST_OBJECT_LOCK(westonimagesrc);

  switch (prop_id) {
  default: {
    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);

  } break;
  }

  GST_OBJECT_UNLOCK(westonimagesrc);
}

static void gst_westonimagesrc_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(object);
  GST_OBJECT_LOCK(westonimagesrc);

  switch (prop_id) {
  default:
    G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
    break;
  }

  GST_OBJECT_UNLOCK(westonimagesrc);
}

static gboolean gst_westonimagesrc_start(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);

  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->running = TRUE;
  westonimagesrc->offset = 0;
  g_mutex_unlock(&westonimagesrc->lock);

  GST_DEBUG_OBJECT(westonimagesrc, "started");
  return TRUE;
}

static gboolean gst_westonimagesrc_stop(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);

  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->running = FALSE;
  g_cond_signal(&westonimagesrc->cond);
  g_mutex_unlock(&westonimagesrc->lock);

  GST_DEBUG_OBJECT(westonimagesrc, "stopped");
  return TRUE;
}

static GstFlowReturn gst_westonimagesrc_create(GstBaseSrc *basesrc, guint64 offset, guint size, GstBuffer **buf) {
  GstWestonImageSrc *src = GST_WESTONIMAGESRC(basesrc);
  GstBuffer *buffer;
  GstMapInfo map;
  GstClockTime dur;

  g_mutex_lock(&src->lock);
  if (!src->running) {
    g_mutex_unlock(&src->lock);
    return GST_FLOW_FLUSHING;
  }
  g_mutex_unlock(&src->lock);

  // Захват кадра
  wl_list_for_each(output, &sh_data.output_list, link) {
    weston_screenshooter_shoot(sh_data.screenshooter, output->output, output->buffer);
    sh_data.buffer_copy_done = 0;

    while (!sh_data.buffer_copy_done)
      wl_display_roundtrip(display);
  }

  // Размер кадра
  size_t frame_size = buff_size.width * buff_size.height * 4; // XRGB
  /* size_t frame_size = buff_size.width * buff_size.height * 3 / 2; */
  buffer = gst_buffer_new_allocate(NULL, frame_size, NULL);
  if (!buffer)
    return GST_FLOW_ERROR;

  if (!gst_buffer_map(buffer, &map, GST_MAP_WRITE)) {
    gst_buffer_unref(buffer);
    return GST_FLOW_ERROR;
  }

  struct screenshooter_output *output = wl_container_of(sh_data.output_list.next, output, link);
  memcpy(map.data, output->data, frame_size);
  gst_buffer_unmap(buffer, &map);

  // Добавляем мета
  gst_buffer_add_video_meta(buffer, GST_VIDEO_FRAME_FLAG_NONE, GST_VIDEO_FORMAT_BGRA, buff_size.width, buff_size.height);

  // PTS и Duration
  dur = gst_util_uint64_scale(GST_SECOND, src->framerate_d, src->framerate_n);
  GST_BUFFER_PTS(buffer) = src->offset * dur;
  GST_BUFFER_DURATION(buffer) = dur;
  src->offset++;

  *buf = buffer;
  return GST_FLOW_OK;
}

static gboolean gst_westonimagesrc_unlock(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);

  GST_DEBUG_OBJECT(westonimagesrc, "unlock");
  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->running = FALSE;
  g_cond_signal(&westonimagesrc->cond);
  g_mutex_unlock(&westonimagesrc->lock);

  return TRUE;
}

static gboolean gst_westonimagesrc_unlock_stop(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);

  GST_DEBUG_OBJECT(westonimagesrc, "unlock stop");
  g_mutex_lock(&westonimagesrc->lock);
  westonimagesrc->running = TRUE;
  g_mutex_unlock(&westonimagesrc->lock);

  return TRUE;
}

static gboolean plugin_init(GstPlugin *plugin) { return gst_element_register(plugin, "westonimagesrc", GST_RANK_NONE, GST_TYPE_WESTONIMAGESRC); }

#ifndef PACKAGE
#  define PACKAGE "westonimagesrc"
#endif

GST_PLUGIN_DEFINE(GST_VERSION_MAJOR, GST_VERSION_MINOR, westonimagesrc, "WestonImageSrc World source plugin", plugin_init, "1.0", "LGPL", "GStreamer", "http://gstreamer.net/")