#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <X11/X.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "display.h"

bool quited = false;

#define WIDTH  640
#define HEIGHT 480

// TODO: correct error handling.
extern int plr_display_x11_main(int argc, char *argv[])
{
    Display *display = XOpenDisplay(NULL);
    if (NULL == display) {
        fprintf(stderr, "Failed to initialize display");
        return EXIT_FAILURE;
    }

    Window root = DefaultRootWindow(display);
    if (None == root) {
        fprintf(stderr, "No root window found");
        XCloseDisplay(display);
        return EXIT_FAILURE;
    }

    int screen = DefaultScreen(display);
    Visual *visual = DefaultVisual(display, screen);
    int depth = DefaultDepth(display, screen);

    Window window = XCreateSimpleWindow(display, root, 0, 0, WIDTH, HEIGHT, 0, 0, 0xffffffff);
    if (None == window) {
        fprintf(stderr, "Failed to create window");
        XCloseDisplay(display);
        return EXIT_FAILURE;
    }

    XSizeHints *hints = XAllocSizeHints();
    if (hints == NULL) return EXIT_FAILURE;

    // Pinning min and max to the same values disables resizing
    hints->flags = PMinSize | PMaxSize;
    hints->min_width = hints->max_width = WIDTH;
    hints->min_height = hints->max_height = HEIGHT;

    XSetWMNormalHints(display, window, hints);
    XFree(hints);

    XSelectInput(display, window, ExposureMask | KeyPressMask);
    XMapWindow(display, window);

    GC gc = XCreateGC(display, window, 0, NULL);

    Atom wm_delete_window = XInternAtom(display, "WM_DELETE_WINDOW", False);
    XSetWMProtocols(display, window, & wm_delete_window, 1);

    // TODO: can't be not true
    int bytes_per_pixel = 4;
    char *pixel_buffer = (char *)malloc(WIDTH * HEIGHT * bytes_per_pixel);

    XImage *ximage = XCreateImage(
        display, visual, depth, ZPixmap, 0, 
        pixel_buffer, WIDTH, HEIGHT, 32, 0
    );

    if (!ximage) {
        fprintf(stderr, "Failed to create XImage\n");
        free(pixel_buffer);
        XCloseDisplay(display);
        return EXIT_FAILURE;
    }

    int frame = 0;

    XEvent event;
    while (!quited) {
        XNextEvent(display, &event);

        switch(event.type) {
        case ClientMessage:
            if(event.xclient.data.l[0] == wm_delete_window) {
                XDestroyWindow(display, window);
                quited = true;
            }
            break;
        case Expose:
            frame += 2;
            // Fill buffer with a simple color gradient
            for (int y = 0; y < HEIGHT; y++) {
                for (int x = 0; x < WIDTH; x++) {
                    int pixel_index = (y * WIDTH + x) * bytes_per_pixel;
                    
                    // Assuming standard Little-Endian 32-bit BGRA format
                    pixel_buffer[pixel_index + 0] = (x + frame) % 256;         // Blue
                    pixel_buffer[pixel_index + 1] = (y + frame) % 256;         // Green
                    pixel_buffer[pixel_index + 2] = (x + y - frame) % 256;     // Red
                    pixel_buffer[pixel_index + 3] = 0;                         // Alpha/Padding
                }
            }
            // Draw the complete image onto the window when exposed
            XPutImage(
                display, 
                window,      // Target drawable
                gc,          // Graphics Context
                ximage,      // Source XImage
                0, 0,        // Source coordinates (x, y)
                0, 0,        // Destination coordinates (x, y)
                WIDTH, HEIGHT// Dimensions to copy
            );
            break;
        }
    }

    XCloseDisplay(display);

    return 0;
}