/*
 * wevent_x11.c — X11 event backend for WINGs.
 *
 * Wraps Xlib event functions and translates XEvent → WMEvent at the
 * boundary.  All code above this layer sees only WMEvent.
 */

#include "wconfig.h"
#include "WINGsP.h"
#include "WINGs/WINGsX11.h"

#include <string.h>
#include <X11/Xlib.h>

/* ------------------------------------------------------------------ */
/* XEvent → WMEvent translation (inline, X11 backend only)            */
/* ------------------------------------------------------------------ */

static void
xev_to_wme(const XEvent *xev, WMEvent *out)
{
    memset(out, 0, sizeof(*out));
    out->_x11_raw = (void *)xev;
    out->window   = (WNativeWindow)xev->xany.window;

    switch (xev->type) {
    case KeyPress:
    case KeyRelease:
        out->type          = (xev->type == KeyPress) ? WME_KEY_PRESS : WME_KEY_RELEASE;
        out->u.key.window  = (WNativeWindow)xev->xkey.window;
        out->u.key.keycode = xev->xkey.keycode;
        out->u.key.state   = xev->xkey.state;
        out->u.key.time    = (unsigned long)xev->xkey.time;
        out->u.key.x       = xev->xkey.x;
        out->u.key.y       = xev->xkey.y;
        out->u.key.x_root  = xev->xkey.x_root;
        out->u.key.y_root  = xev->xkey.y_root;
        break;

    case ButtonPress:
    case ButtonRelease:
        out->type             = (xev->type == ButtonPress) ? WME_BUTTON_PRESS : WME_BUTTON_RELEASE;
        out->u.button.window  = (WNativeWindow)xev->xbutton.window;
        out->u.button.subwindow = (WNativeWindow)xev->xbutton.subwindow;
        out->u.button.button  = xev->xbutton.button;
        out->u.button.state   = xev->xbutton.state;
        out->u.button.x       = xev->xbutton.x;
        out->u.button.y       = xev->xbutton.y;
        out->u.button.x_root  = xev->xbutton.x_root;
        out->u.button.y_root  = xev->xbutton.y_root;
        out->u.button.time    = (unsigned long)xev->xbutton.time;
        out->u.button.send_event = xev->xbutton.send_event;
        break;

    case MotionNotify:
        out->type               = WME_MOTION;
        out->u.motion.window    = (WNativeWindow)xev->xmotion.window;
        out->u.motion.subwindow = (WNativeWindow)xev->xmotion.subwindow;
        out->u.motion.state     = xev->xmotion.state;
        out->u.motion.time      = (unsigned long)xev->xmotion.time;
        out->u.motion.x         = xev->xmotion.x;
        out->u.motion.y         = xev->xmotion.y;
        out->u.motion.x_root    = xev->xmotion.x_root;
        out->u.motion.y_root    = xev->xmotion.y_root;
        break;

    case EnterNotify:
    case LeaveNotify:
        out->type              = (xev->type == EnterNotify) ? WME_ENTER : WME_LEAVE;
        out->u.crossing.window = (WNativeWindow)xev->xcrossing.window;
        out->u.crossing.state  = xev->xcrossing.state;
        out->u.crossing.time   = (unsigned long)xev->xcrossing.time;
        out->u.crossing.x      = xev->xcrossing.x;
        out->u.crossing.y      = xev->xcrossing.y;
        out->u.crossing.x_root = xev->xcrossing.x_root;
        out->u.crossing.y_root = xev->xcrossing.y_root;
        out->u.crossing.mode   = xev->xcrossing.mode;
        out->u.crossing.detail = xev->xcrossing.detail;
        break;

    case Expose:
        out->type            = WME_EXPOSE;
        out->u.expose.window = (WNativeWindow)xev->xexpose.window;
        out->u.expose.x      = xev->xexpose.x;
        out->u.expose.y      = xev->xexpose.y;
        out->u.expose.width  = xev->xexpose.width;
        out->u.expose.height = xev->xexpose.height;
        out->u.expose.count  = xev->xexpose.count;
        break;

    case ConfigureNotify:
        out->type                         = WME_CONFIGURE;
        out->u.configure.window           = (WNativeWindow)xev->xconfigure.window;
        out->u.configure.event            = (WNativeWindow)xev->xconfigure.event;
        out->u.configure.x                = xev->xconfigure.x;
        out->u.configure.y                = xev->xconfigure.y;
        out->u.configure.width            = xev->xconfigure.width;
        out->u.configure.height           = xev->xconfigure.height;
        out->u.configure.border_width     = xev->xconfigure.border_width;
        out->u.configure.above            = (WNativeWindow)xev->xconfigure.above;
        out->u.configure.override_redirect = xev->xconfigure.override_redirect;
        break;

    case MapNotify:
        out->type                          = WME_MAP;
        out->u.lifecycle.window            = (WNativeWindow)xev->xmap.window;
        out->u.lifecycle.event             = (WNativeWindow)xev->xmap.event;
        out->u.lifecycle.override_redirect = xev->xmap.override_redirect;
        break;

    case UnmapNotify:
        out->type                 = WME_UNMAP;
        out->u.lifecycle.window   = (WNativeWindow)xev->xunmap.window;
        out->u.lifecycle.event    = (WNativeWindow)xev->xunmap.event;
        break;

    case DestroyNotify:
        out->type                 = WME_DESTROY;
        out->u.lifecycle.window   = (WNativeWindow)xev->xdestroywindow.window;
        out->u.lifecycle.event    = (WNativeWindow)xev->xdestroywindow.event;
        break;

    case FocusIn:
    case FocusOut:
        out->type            = (xev->type == FocusIn) ? WME_FOCUS_IN : WME_FOCUS_OUT;
        out->u.focus.window  = (WNativeWindow)xev->xfocus.window;
        out->u.focus.mode    = xev->xfocus.mode;
        out->u.focus.detail  = xev->xfocus.detail;
        break;

    case PropertyNotify:
        out->type              = WME_PROPERTY;
        out->u.property.window = (WNativeWindow)xev->xproperty.window;
        out->u.property.atom   = (unsigned long)xev->xproperty.atom;
        out->u.property.time   = (unsigned long)xev->xproperty.time;
        out->u.property.state  = xev->xproperty.state;
        break;

    case SelectionNotify:
        out->type                  = WME_SELECTION;
        out->u.selection.window    = (WNativeWindow)xev->xselection.requestor;
        out->u.selection.selection = (unsigned long)xev->xselection.selection;
        out->u.selection.target    = (unsigned long)xev->xselection.target;
        out->u.selection.property  = (unsigned long)xev->xselection.property;
        out->u.selection.time      = (unsigned long)xev->xselection.time;
        break;

    case SelectionRequest:
        out->type                   = WME_SELECTION_REQUEST;
        out->u.selection.window     = (WNativeWindow)xev->xselectionrequest.owner;
        out->u.selection.requestor  = (WNativeWindow)xev->xselectionrequest.requestor;
        out->u.selection.selection  = (unsigned long)xev->xselectionrequest.selection;
        out->u.selection.target     = (unsigned long)xev->xselectionrequest.target;
        out->u.selection.property   = (unsigned long)xev->xselectionrequest.property;
        out->u.selection.time       = (unsigned long)xev->xselectionrequest.time;
        break;

    case SelectionClear:
        out->type                  = WME_SELECTION_CLEAR;
        out->u.selection.window    = (WNativeWindow)xev->xselectionclear.window;
        out->u.selection.selection = (unsigned long)xev->xselectionclear.selection;
        out->u.selection.time      = (unsigned long)xev->xselectionclear.time;
        break;

    case ClientMessage:
        out->type                         = WME_CLIENT_MESSAGE;
        out->u.clientMessage.window       = (WNativeWindow)xev->xclient.window;
        out->u.clientMessage.message_type = (unsigned long)xev->xclient.message_type;
        out->u.clientMessage.format       = xev->xclient.format;
        memcpy(out->u.clientMessage.data.b, xev->xclient.data.b, 20);
        break;

    case VisibilityNotify:
        out->type                = WME_VISIBILITY;
        out->u.visibility.window = (WNativeWindow)xev->xvisibility.window;
        out->u.visibility.state  = xev->xvisibility.state;
        break;

    case ColormapNotify:
        out->type                = WME_COLORMAP;
        out->u.colormap.window   = (WNativeWindow)xev->xcolormap.window;
        out->u.colormap.colormap = (unsigned long)xev->xcolormap.colormap;
        out->u.colormap.c_new    = xev->xcolormap.new;
        out->u.colormap.state    = xev->xcolormap.state;
        break;

    case MappingNotify:
        out->type                    = WME_MAPPING;
        out->u.mapping.request       = xev->xmapping.request;
        out->u.mapping.first_keycode = xev->xmapping.first_keycode;
        out->u.mapping.count         = xev->xmapping.count;
        break;

    default:
        out->type = WME_NONE;
        break;
    }
}

/* ------------------------------------------------------------------ */
/* WMEvent → XEvent reverse translation (for put_back)                */
/* We store the _x11_raw pointer, so put_back just uses that.         */
/* For events without _x11_raw (shouldn't happen in X11 mode), no-op. */
/* ------------------------------------------------------------------ */

/* ------------------------------------------------------------------ */
/* Backend vtable implementation                                       */
/* ------------------------------------------------------------------ */

/* Per-screen context: just the Display pointer. */
typedef struct {
    Display *dpy;
    /* We need to store the last fetched XEvent so _x11_raw remains valid
     * until the next fetch.  Use a small ring buffer. */
    XEvent xev_buf[4];
    int    xev_idx;
} X11EventCtx;

static void *
x11_screen_init(W_Screen *scr)
{
    X11EventCtx *ctx = wmalloc(sizeof(*ctx));
    memset(ctx, 0, sizeof(*ctx));
    ctx->dpy = scr->display;
    return ctx;
}

static void
x11_screen_fini(void *ectx)
{
    wfree(ectx);
}

static Bool
x11_pending(void *ectx)
{
    X11EventCtx *ctx = ectx;
    return XPending(ctx->dpy) > 0;
}

static void
x11_fetch(void *ectx, WMEvent *ev)
{
    X11EventCtx *ctx = ectx;
    XEvent *slot = &ctx->xev_buf[ctx->xev_idx];
    ctx->xev_idx = (ctx->xev_idx + 1) % 4;
    XNextEvent(ctx->dpy, slot);

    /* X11-specific pre-processing */
    if (slot->type == MappingNotify)
        XRefreshKeyboardMapping(&slot->xmapping);
    if (XFilterEvent(slot, WM_NATIVE_NONE) == True) {
        /* Consumed by input method — return a no-op event */
        memset(ev, 0, sizeof(*ev));
        ev->type = WME_NONE;
        ev->_view_target = NULL;
        return;
    }

    xev_to_wme(slot, ev);
    ev->_view_target = W_GetViewForXWindow(ctx->dpy, slot->xany.window);
}

static Bool
x11_check_mask(void *ectx, long mask, WMEvent *ev)
{
    X11EventCtx *ctx = ectx;
    XEvent *slot = &ctx->xev_buf[ctx->xev_idx];
    if (XCheckMaskEvent(ctx->dpy, mask, slot)) {
        ctx->xev_idx = (ctx->xev_idx + 1) % 4;
        xev_to_wme(slot, ev);
        ev->_view_target = W_GetViewForXWindow(ctx->dpy, slot->xany.window);
        return True;
    }
    return False;
}

static Bool
x11_check_typed_window(void *ectx, WNativeWindow w, int type, WMEvent *ev)
{
    X11EventCtx *ctx = ectx;
    /* Map WMEventType back to X11 event type for XCheckTypedWindowEvent.
     * This is only called for WME_EXPOSE (Expose compression). */
    int xtype;
    switch (type) {
    case WME_EXPOSE: xtype = Expose; break;
    case WME_MOTION: xtype = MotionNotify; break;
    default: return False;
    }
    XEvent *slot = &ctx->xev_buf[ctx->xev_idx];
    if (XCheckTypedWindowEvent(ctx->dpy, (Window)w, xtype, slot)) {
        ctx->xev_idx = (ctx->xev_idx + 1) % 4;
        xev_to_wme(slot, ev);
        ev->_view_target = W_GetViewForXWindow(ctx->dpy, slot->xany.window);
        return True;
    }
    return False;
}

static void
x11_flush(void *ectx, Bool discard)
{
    X11EventCtx *ctx = ectx;
    XSync(ctx->dpy, discard);
}

static int
x11_fd(void *ectx)
{
    X11EventCtx *ctx = ectx;
    return ConnectionNumber(ctx->dpy);
}

static void
x11_put_back(void *ectx, WMEvent *ev)
{
    X11EventCtx *ctx = ectx;
    /* If we have the original XEvent, put it back via Xlib */
    if (ev->_x11_raw) {
        XPutBackEvent(ctx->dpy, (XEvent *)ev->_x11_raw);
    }
    /* If no _x11_raw (shouldn't happen in X11 mode), event is lost */
}

static void
x11_post_dispatch(void *ectx, WMEvent *ev, W_View *toplevel)
{
    (void)ectx;
    if (!ev->_x11_raw)
        return;
    XEvent *xev = (XEvent *)ev->_x11_raw;
    if (ev->type == WME_SELECTION || ev->type == WME_SELECTION_CLEAR ||
        ev->type == WME_SELECTION_REQUEST) {
        W_HandleSelectionEvent(xev);
    }
    if (ev->type == WME_CLIENT_MESSAGE) {
        W_HandleDNDClientMessage(toplevel, &xev->xclient);
    }
}

const W_EventBackend W_EventBackendX11 = {
    .screen_init         = x11_screen_init,
    .screen_fini         = x11_screen_fini,
    .pending             = x11_pending,
    .fetch               = x11_fetch,
    .check_mask          = x11_check_mask,
    .check_typed_window  = x11_check_typed_window,
    .flush               = x11_flush,
    .fd                  = x11_fd,
    .put_back            = x11_put_back,
    .post_dispatch       = x11_post_dispatch,
};