#include <poll.h>
#include <curses.h>
#include <stdio.h>
#include <string.h>
#include <syscall.h>
#include <unistd.h>
#include <sys/mman.h>
#include <wayland-client.h>
#include "xdg-shell-client-protocol.h"

struct wl_compositor *compositor;
struct wl_shm *shm;
struct xdg_wm_base *wm_base;

void wm_base_ping_handler
  ( void *data,
    struct xdg_wm_base *wm_base,
    uint32_t serial )
  { xdg_wm_base_pong(wm_base, serial); }
const struct xdg_wm_base_listener wm_base_listener
    = { .ping = wm_base_ping_handler };

void registry_global_handler
  ( void *data,
    struct wl_registry *registry,
    uint32_t name,
    const char *interface,
    uint32_t version )
  {
    if (strcmp(interface, "wl_compositor") == 0) {
        compositor = wl_registry_bind(registry, name,
            &wl_compositor_interface, 3);
    } else if (strcmp(interface, "wl_shm") == 0) {
        shm = wl_registry_bind(registry, name,
            &wl_shm_interface, 1);
    } else if (strcmp(interface, "xdg_wm_base") == 0) {
        wm_base = wl_registry_bind(registry, name,
            &xdg_wm_base_interface, 1);
        xdg_wm_base_add_listener(wm_base, &wm_base_listener, NULL);
    }
  }

void registry_global_remove_handler
  ( void *data,
    struct wl_registry *registry,
    uint32_t name ) {}

const struct wl_registry_listener registry_listener = {
    .global = registry_global_handler,
    .global_remove = registry_global_remove_handler   };

void xdg_surface_configure_handler
  ( void *data,
    struct xdg_surface *xdg_surface,
    uint32_t serial )
  { xdg_surface_ack_configure(xdg_surface, serial); }

const struct xdg_surface_listener xdg_surface_listener = {
    .configure = xdg_surface_configure_handler };

int dispatch_or_stdin(struct wl_display *display) {
    while (wl_display_prepare_read(display) != 0)
    wl_display_dispatch_pending(display);
    wl_display_flush(display);

    struct pollfd fds[2] = {
        { .fd = wl_display_get_fd(display), .events = POLLIN },
        { .fd = STDIN_FILENO,               .events = POLLIN } };

    poll(fds, 2, -1);
    if (fds[0].revents & POLLIN)
        wl_display_read_events(display);
    else
        wl_display_cancel_read(display);
    wl_display_dispatch_pending(display);
    return 0;
 }

int main(void){ unsigned i;
    struct wl_display *display = wl_display_connect(NULL);
    struct wl_registry *registry = wl_display_get_registry(display);
    wl_registry_add_listener(registry, &registry_listener, NULL);
    wl_display_roundtrip(display);
    if (!compositor || !shm || !wm_base) {
        fprintf(stderr,
            "missing required global: compositor=%p shm=%p wm_base=%p\n",
            (void *)compositor, (void *)shm, (void *)wm_base); return 1; }

    struct wl_surface *surface = wl_compositor_create_surface(compositor);
    struct xdg_surface *xdg_surface = xdg_wm_base_get_xdg_surface(wm_base, surface);
    xdg_surface_add_listener(xdg_surface, &xdg_surface_listener, NULL);
    struct xdg_toplevel *xdg_toplevel = xdg_surface_get_toplevel(xdg_surface);
    xdg_toplevel_set_title(xdg_toplevel, "square");
    wl_surface_commit(surface);
    wl_display_roundtrip(display);

    int width = 512;
    int height =768;
    int stride = width * 4;
    int size = stride * height;
    int fd = syscall(SYS_memfd_create, "buffer", 0);
    ftruncate(fd, size);
    
    unsigned char *data = mmap(NULL, size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    struct wl_shm_pool *pool = wl_shm_create_pool(shm, fd, size);
    struct wl_buffer *buffer = wl_shm_pool_create_buffer(pool,
        0, width, height, stride, WL_SHM_FORMAT_XRGB8888);

    wl_surface_attach(surface, buffer, 0, 0);
    wl_surface_commit(surface);

    initscr(); timeout(0);
    while (getch()==ERR) dispatch_or_stdin(display);

    for(i=0;i<0x20000;i++) data[i]=255;   
    wl_surface_damage(surface,0,0,2048,256);
    wl_surface_commit(surface);
    while (getch()==ERR) dispatch_or_stdin(display);

    for(i=0;i<0x40000;i++) data[i]=255;   
    wl_surface_damage(surface,0,0,2048,256);
    wl_surface_commit(surface);
    while (getch()==ERR) dispatch_or_stdin(display);
    
    for(i=0;i<0x60000;i++) data[i]=255;   
    wl_surface_damage(surface,0,0,2048,256);
    wl_surface_commit(surface);
    while (getch()==ERR) dispatch_or_stdin(display);

    for(i=0;i<0x80000;i++) data[i]=255;   
    wl_surface_damage(surface,0,0,2048,256);
    wl_surface_commit(surface);
    while (getch()==ERR) dispatch_or_stdin(display);

    endwin(); }