#include <stdio.h>
#include <assert.h>

#include <wayland-client.h>

#include <sys/mman.h>
#include <fcntl.h>


struct display {
    struct wl_display *display;
    struct wl_compositor *compositor;
    struct wl_registry *registry;
    struct wl_shm *shm;
    struct wl_shell *shell;
    struct
    {
        int32_t x, y, width, height;
    } screen_allocation;
};

struct monbuffer {
    struct wl_buffer *buffer;
    void *shm_data;
    int busy;
};

struct window {
    struct display *display;
    struct wl_surface *surface;
    struct wl_shell_surface *shell_surface;
    struct monbuffer buffers[2];
    struct wl_callback *callback;
    int width;
    int height;
};



static void
registry_handle_global (void *data, struct wl_registry *registry, uint32_t id, const char *interface, uint32_t version)
{
    struct display *d = data;

    if (strcmp(interface, "wl_compositor") == 0) {
        d->compositor = wl_registry_bind (registry, id, &wl_compositor_interface, 1);
    } else if (strcmp(interface, "wl_shell") == 0) {
        d->shell = wl_registry_bind (registry, id, &wl_shell_interface, 1);
    } else if (strcmp(interface, "wl_shm") == 0) {
        d->shm = wl_registry_bind (registry, id, &wl_shm_interface, 1);
    }
}

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

static const struct wl_registry_listener registry_listener = {
    registry_handle_global,
    registry_handle_global_remove
};


static void
handle_ping(void *data, struct wl_shell_surface *shell_surface, uint32_t serial)
{
    wl_shell_surface_pong (shell_surface, serial);
}

static const struct wl_shell_surface_listener shell_surface_listener = {
    handle_ping
};


static void
buffer_release(void *data, struct wl_buffer *buffer)
{
    struct monbuffer *monbuf = data;
    monbuf->busy = 0;
}

static const struct wl_buffer_listener buffer_listener = {
    buffer_release
};


static const struct wl_callback_listener frame_listener;

static void
redraw(void *data, struct wl_callback *callback, uint32_t time)
{
    struct window *window = data;

    struct monbuffer *buffer;
    if (!window->buffers[0].busy)
        buffer = &window->buffers[0];
    else if (!window->buffers[0].busy)
        buffer = &window->buffers[1];
    else
        return NULL;

    if (!buffer->busy)
    {
        const char fd_name[] = "/tmp/tarnyko-shm.swp";
        int fd = open (fd_name, O_CREAT | O_RDWR | O_TRUNC);
        if (fd < 0)
        {
            printf ("Impossible de créer un fichier tampon !\n");
            exit (-1);
        }
        long flags = fcntl (fd, F_GETFD);
        if (fcntl (fd, F_SETFD, flags | FD_CLOEXEC) < 0)
        {
            printf ("Pas de CLOEXEC !\n");
            exit (-1);
        }
        if (ftruncate (fd, 320*240*4) < 0)
        {
            printf ("Impossible d'allouer l'espace dans le fichier tampon !\n");
            exit (-1);
        }

        void *fd_contenu;
        fd_contenu = mmap (0, 320*240*4, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
        if (fd_contenu == MAP_FAILED)
        {
            printf ("Impossible d'allouer de l'espace dans le fichier tampon !\n");
            close (fd);
            exit (-1);
        }

        int result = 0;
        struct wl_shm_pool *pool;
        pool = wl_shm_create_pool(window->display->shm, fd, 320*240*4);
        buffer->buffer = wl_shm_pool_create_buffer (pool, 0, 320, 240, 320*4, WL_SHM_FORMAT_XRGB8888);

        wl_buffer_add_listener (buffer->buffer, &buffer_listener, buffer);

        wl_shm_pool_destroy(pool);
        close (fd);

        buffer->shm_data = fd_contenu;
        memset(buffer->shm_data, 0xff, 320*240*4);
    }

         // XXXXXXX TO BE CONTINUED ! DRAW SOMETHING !
        //paint_pixels(buffer->shm_data, 20, window->width, window->height, time);

        uint32_t *pixels = buffer->shm_data;
        pixels += 20*320;

        wl_surface_attach(window->surface, buffer->buffer, 0, 0);
        wl_surface_damage(window->surface, 0, 0, 320, 240);

            // callback on itself
    if (callback)
        wl_callback_destroy (callback);
    window->callback = wl_surface_frame (window->surface);
    wl_callback_add_listener (window->callback, &frame_listener, window);
    wl_surface_commit (window->surface);

        buffer->busy = 1;
}

static const struct wl_callback_listener frame_listener = {
    redraw
};



int main ()
{
    struct display *display;
    display = malloc (sizeof *display);

    display->display = wl_display_connect (NULL);
    assert (display->display != NULL);

    display->registry = wl_display_get_registry (display->display);
    wl_registry_add_listener (display->registry, &registry_listener, display);

    wl_display_roundtrip (display->display);
    assert (display->shm != NULL);
    wl_display_roundtrip (display->display);
    wl_display_get_fd (display->display);

    struct window *window;
    window = malloc (sizeof *window);
     // 2nd WINDOW !
    struct window *window2;
    window2 = malloc (sizeof *window);

        window->display = display;
        window2->display = display;
        window->buffers[0].busy = 0;
        window->buffers[1].busy = 0;
        window->callback = NULL;
        window2->buffers[0].busy = 0;
        window2->buffers[1].busy = 0;
        window2->callback = NULL;
    window->surface = wl_compositor_create_surface (display->compositor);
    window->shell_surface = wl_shell_get_shell_surface (display->shell, window->surface);
    window2->surface = wl_compositor_create_surface (display->compositor);
    window2->shell_surface = wl_shell_get_shell_surface (display->shell, window2->surface);

     // LET'S POSITION THEM RELATIVELY
wl_shell_surface_set_transient (window2->shell_surface, window->surface, 100, 100, 0);

    wl_shell_surface_add_listener(window->shell_surface, &shell_surface_listener, window);
    wl_shell_surface_add_listener(window2->shell_surface, &shell_surface_listener, window2);

    wl_shell_surface_set_title (window->shell_surface, "Exemple SHM");
    wl_shell_surface_set_toplevel (window->shell_surface);
    wl_shell_surface_set_title (window2->shell_surface, "Exemple SHM 2");
    wl_shell_surface_set_toplevel (window2->shell_surface);
    wl_surface_damage (window->surface, 0, 0, 320, 240);
    wl_surface_damage (window2->surface, 0, 0, 320, 240);

     // MAIN DRAWING FUNCTION
    redraw (window, NULL, 0);
    redraw (window2, NULL, 0);


     // MAIN LOOP
    int result = 0;
    while (result != -1)
        result = wl_display_dispatch (display->display);


    wl_registry_destroy (display->registry);
    wl_display_flush (display->display);
    wl_display_disconnect (display->display);


    return 0;
}