#include <assert.h>

#include "any_log.h"
#include "util.h"
#include "layout.h"
#include "event.h"
#include "block.h"

const char *event_type_to_string(event_type_t type)
{
    const char *types[] = {
        "hover",
        "left_click",
        "middle_click",
        "right_click",
        "scroll_up",
        "scroll_down",
        "trigger",
    };

    assert(type >= EVENT_HOVER && type <= EVENT_TRIGGER);
    return types[type];
}

bool event_is_hover(event_t event)
{
    return event.type == EVENT_HOVER;
}

bool event_is_click(event_t event)
{
    return event.type == EVENT_LEFT_CLICK
        || event.type == EVENT_MIDDLE_CLICK
        || event.type == EVENT_RIGHT_CLICK;
}

bool event_is_scroll(event_t event)
{
    return event.type == EVENT_SCROLL_UP
        || event.type == EVENT_SCROLL_DOWN;
}

static bool event_dispatch_mouse(layout_t *layout, event_t event)
{
    int width  = layout->width  - 2 * layout->x_padding;
    int height = layout->height - 2 * layout->y_padding;

    if (!check_capsule(event.x, event.y, layout->x, layout->y, width, height))
        return false;

    for (int i = 0; i < layout->n_children; i++) {
        if (event_dispatch_mouse(&layout->children[i], event))
            return true;
    }

    block_event_t event_fn = layout->block->type == BLOCK_SPEC
                           ? ((block_spec_t *)layout->block)->event_fn
                           : NULL;

    log_value_debug("Block received a mouse interaction",
                    "s:event", event_type_to_string(event.type),
                    "i:event_x", event.x,
                    "i:event_y", event.y,
                    "s:label", layout->block->label,
                    "i:x", layout->x,
                    "i:y", layout->y,
                    "i:width", layout->width,
                    "i:height", layout->height,
                    "b:callback", event_fn != NULL);

    if (event_fn != NULL) {
        event_fn(layout, event);
        log_trace("Completed event callback");
    }

    return true;
}

static void event_dispatch_once(window_t *window, layout_t *layout, xcb_generic_event_t *xevent)
{
    int type = xevent->response_type & ~0x80;
    switch (type) {
        case 0: {
            xcb_generic_error_t *error = (xcb_generic_error_t *)xevent;

            const char *extension = NULL;
            const char *name  = xcb_errors_get_name_for_error(window->display->errors, error->error_code, &extension);
            const char *major = xcb_errors_get_name_for_major_code(window->display->errors, error->major_code);
            const char *minor = xcb_errors_get_name_for_minor_code(window->display->errors, error->major_code, error->minor_code);

            log_value_error("Xcb error",
                            "s:name", name,
                            "s:extension", extension ? extension : "none",
                            "s:major", major,
                            "s:minor", minor ? minor : "none",
                            "u:resource", (unsigned int)error->resource_id,
                            "u:sequence", (unsigned int)error->sequence);

            // TODO: Handle errors instead of aborting
            abort();
            break;
        }

        case XCB_EXPOSE: {
            xcb_expose_event_t *expose = (xcb_expose_event_t *)xevent;
            log_trace("Processing 'Expose' event");

            // Redraw
            (void)expose;
            break;
        }

        case XCB_CREATE_NOTIFY: {
            xcb_create_notify_event_t *create = (xcb_create_notify_event_t *)xevent;
            log_trace("Processing 'CreateNotify' event");

            (void)create;

            if (window->cw_params.override_redirect) break;
            xcb_circulate_window(window->display->connection, XCB_CIRCULATE_RAISE_LOWEST, window->window);
            break;
        }

        case XCB_LEAVE_NOTIFY: {
            xcb_leave_notify_event_t *leave = (xcb_leave_notify_event_t *)xevent;
            log_trace("Processing 'LeaveNotify' event");

            if (leave->event != window->window) break;
            // Leaving
            break;
        }

        case XCB_BUTTON_RELEASE: {
            xcb_button_release_event_t *button = (xcb_button_release_event_t *)xevent;
            log_trace("Processing 'ButtonRelease' event");

            if (button->detail < XCB_BUTTON_INDEX_1 || button->detail > XCB_BUTTON_INDEX_5) {
                log_value_trace("Ignoring button release",
                                "u:value", button->detail);
                break;
            }

            event_t event = {
                .x = button->event_x,
                .y = button->event_y,
                .type = button->detail,
            };

            event_dispatch_mouse(layout, event);
            break;
        }

        case XCB_PROPERTY_NOTIFY: {
            xcb_property_notify_event_t *property = (xcb_property_notify_event_t *)xevent;
            log_trace("Processing 'PropertyNotify' event");

            if (property->atom == XCB_ATOM_RESOURCE_MANAGER) {
                display_update_xrm(window->display);
                display_update_scale(window->display);
                // Redraw
            }
            break;
        }

        case XCB_MOTION_NOTIFY: {
            xcb_motion_notify_event_t *motion = (xcb_motion_notify_event_t *)xevent;
            log_trace("Processing 'MotionNotify' event");

            event_t event = {
                .x = motion->event_x,
                .y = motion->event_y,
                .type = EVENT_HOVER,
            };

            event_dispatch_mouse(layout, event);
            break;
        }

        default: {
            const char *extension = NULL;
            const char *name = xcb_errors_get_name_for_xcb_event(window->display->errors, xevent, &extension);

            log_value_trace("Ignoring Xcb event",
                            "s:name", name,
                            "u:type", type,
                            "s:extension", extension ? extension : "none");
            break;
        }
    }
}

void event_dispatch(window_t *window, layout_t *layout)
{
    xcb_generic_event_t *xevent, *motion = NULL;
    while ((xevent = xcb_poll_for_event(window->display->connection)) != NULL) {

        int type = xevent->response_type & ~0x80;
        if (type == XCB_MOTION_NOTIFY) {
            free(motion);
            motion = xevent;
            continue;
        }

        event_dispatch_once(window, layout, xevent);
        free(xevent);
    }

    // We only consider the last motion notify received
    //
    if (motion != NULL) {
        event_dispatch_once(window, layout, motion);
        free(motion);
    }
}