#include <errno.h>
#include <fcntl.h>
#include <limits.h>
#include <linux/input-event-codes.h>
#include <linux/uinput.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 <msgpack.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,
};

// 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 GstCaps *gst_westonimagesrc_get_caps(GstBaseSrc *src, GstCaps *filter);
static gboolean gst_westonimagesrc_negotiate(GstBaseSrc *basesrc);

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 fd, int type, int code, int value);

static void rcontrol_emit(GstWestonImageSrc *westonimagesrc, int fd, 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(fd, &ev, sizeof(ev)) < 0) {
    GST_WARNING_OBJECT(westonimagesrc, "write() input_event %i:%i:%i:%i failed", fd, type, code, value);
  }
}

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

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_INET, SOCK_DGRAM, 0);
  if (westonimagesrc->udp_socket_fd < 0) {
    GST_WARNING_OBJECT(westonimagesrc, "socket() UDP socket creation failed");
    return NULL;
  }

  struct sockaddr_in addr;
  memset(&addr, 0, sizeof(addr));
  addr.sin_family = AF_INET;
  addr.sin_port = htons(port);
  addr.sin_addr.s_addr = INADDR_ANY;

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

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

  char buf[1024u];
  msgpack_zone mempool;
  msgpack_zone_init(&mempool, sizeof(buf));

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

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

    buf[len] = '\0';

    msgpack_object deserialized;
    msgpack_unpack(buf, sizeof(buf), NULL, &mempool, &deserialized);
    GST_INFO_OBJECT(westonimagesrc, "[UDP %s:%d]: %s\r\n", inet_ntoa(src.sin_addr), ntohs(src.sin_port), deserialized.via.str.ptr);
  }

  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) {
  struct uinput_user_dev uud;

  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 events
    ioctl(westonimagesrc->uinput_fd, UI_SET_EVBIT, EV_REL);

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

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

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

  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->get_caps = NULL;
  gstbasesrc_class->negotiate = GST_DEBUG_FUNCPTR(gst_westonimagesrc_negotiate);
  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 GstCaps *gst_westonimagesrc_get_caps(GstBaseSrc *src, GstCaps *filter) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(src);

  GstCaps *caps = gst_caps_new_simple("video/x-raw", "format", GST_TYPE_VIDEO_FORMAT, westonimagesrc->format, "width", G_TYPE_INT, westonimagesrc->width, "height", G_TYPE_INT,
                                      westonimagesrc->height, "framerate", GST_TYPE_FRACTION, westonimagesrc->framerate_n, westonimagesrc->framerate_d, NULL);

  if (filter) {
    GstCaps *tmp = gst_caps_intersect_full(filter, caps, GST_CAPS_INTERSECT_FIRST);
    gst_caps_unref(caps);
    return tmp;
  }

  return caps;
}

static gboolean gst_westonimagesrc_negotiate(GstBaseSrc *basesrc) {
  GstWestonImageSrc *westonimagesrc = GST_WESTONIMAGESRC(basesrc);
  GstCaps *caps;
  GstStructure *s;

  caps = gst_pad_get_current_caps(GST_BASE_SRC_PAD(basesrc));
  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);

  gst_caps_unref(caps);
  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/")