#include "wm.h"

static char broken[] = "broken";

void
focus(Client *client, int lift)
{
    struct wlr_seat        *seat;
    struct wlr_surface     *old, *new;
    struct wlr_xdg_surface *xdg;
    struct wlr_keyboard    *keyboard;

    new = server.input.seat->keyboard_state.focused_surface;

    if(client && lift) {
        wl_list_remove(&client->stack);
        wl_list_insert(&server.client.stack, &client->stack);
    }

    seat = server.input.seat;
    old  = seat->keyboard_state.focused_surface;

    if(old==new)
        return;

    if(client) {
        wl_list_remove(&client->focus);
        wl_list_insert(&server.client.focus, &client->focus);
        server.monitor.selected = client->monitor;
        client->isurgent = 0;
    }

    if(old) {
        xdg = wlr_xdg_surface_from_wlr_surface(seat->keyboard_state.focused_surface);
        wlr_xdg_toplevel_set_activated(xdg, false);
    }

    if(!client) {
        wlr_seat_keyboard_notify_clear_focus(seat);
        return;
    }

    keyboard = wlr_seat_get_keyboard(seat);

    wlr_seat_keyboard_notify_enter(seat, client->xdg->surface,
        keyboard->keycodes,
        keyboard->num_keycodes,
        &keyboard->modifiers
    );

    wlr_xdg_toplevel_set_activated(client->xdg, true);
}

int
client_has(Client *client, double lx, double ly, struct wlr_surface **surface, double *sx, double *sy)
{
    double x, y, vsx = lx - client->geometry.x, vsy = ly - client->geometry.y;
    struct wlr_surface *find = nil;

    find = wlr_xdg_surface_surface_at(client->xdg, vsx, vsy, &x, &y);
    if(find) {
        *sx = x;
        *sy = y;
        *surface = find;
        return true;
    }

    return false;
}

Client*
client_at(double lx, double ly, struct wlr_surface **surface, double *sx, double *sy)
{
    Client *it;
    wl_list_for_each(it, &server.client.list, link) {
        if(client_has(it, lx, ly, surface, sx, sy))
            return it;
    }

    return nil;
}

void
setinteractive(Client *client, int mode, uint32 edges) {
    double bx, by;
    struct wlr_box box;
    struct wlr_surface *focused = server.input.seat->pointer_state.focused_surface;

    if(client->xdg->surface != focused)
        return;

    server.grab.client = client;
    server.cursor.mode = mode;

    if(mode == CursorMove) {
        server.grab.x = server.cursor.dot->x - client->geometry.x;
        server.grab.y = server.cursor.dot->y - client->geometry.y;
    } else {
        wlr_xdg_surface_get_geometry(client->xdg, &box);

        bx = (client->geometry.x + box.x) + ((edges & WLR_EDGE_RIGHT)  ? box.width  : 0);
        by = (client->geometry.y + box.y) + ((edges & WLR_EDGE_BOTTOM) ? box.height : 0);

        server.grab.x = server.cursor.dot->x - bx;
        server.grab.y = server.cursor.dot->y - by;

        server.grab.box = box;
        server.grab.box.x += client->geometry.x;
        server.grab.box.y += client->geometry.y;

        server.resize = edges;
    }
}

static
void
constrain(Client *client, struct wlr_box *box)
{
    client->geometry.width  = MAX(1, client->geometry.width);
    client->geometry.height = MAX(1, client->geometry.height);

    if(client->geometry.x >= box->x + box->width)
        client->geometry.x = box->x + box->width  - client->geometry.width;
    if(client->geometry.y >= box->y + box->height)
        client->geometry.y = box->y + box->height - client->geometry.height;
    if(client->geometry.x + client->geometry.width  + 2*client->border <= box->x)
        client->geometry.x = box->x;
    if(client->geometry.y + client->geometry.height + 2*client->border <= box->y)
        client->geometry.y = box->y;
}

void
resize(Client *client, int x, int y, int w, int h, int interact)
{
    struct wlr_box *box = interact ? &server.monitor.geometry : &client->monitor->window;

    client->geometry.x = x;
    client->geometry.y = y;
    client->geometry.width  = w;
    client->geometry.height = h;

    constrain(client, box);

    client->resize = wlr_xdg_toplevel_set_size(client->xdg,
            client->geometry.width  - 2*client->border,
            client->geometry.height - 2*client->border
    );
}

void
attach(Client *client, Monitor *monitor, uint tags)
{
    Monitor *old = client->monitor;
    if(old == monitor)
        return;

    client->monitor = monitor;

    if(old) {
        wlr_surface_send_leave(client->xdg->surface, old->output);
        arrange(old);
    }

    if(monitor) {
        /* make sure window actually overlaps with the monitor */
        constrain(client, &monitor->geometry);
        wlr_surface_send_enter(client->xdg->surface, monitor->output);
        client->tags = tags ? tags : monitor->tag.set[monitor->tag.selected];
        arrange(monitor);
    }

    focus(focused_client(server.monitor.selected), 1);
}

void
rules(Client *client)
{
    /* rule matching */
    Rule *rule;
    uint i, tags;
    char *id, *title;
    Monitor *monitor, *it;

    monitor = server.monitor.selected;

    if (!(id=client->xdg->toplevel->app_id))
        id = broken;
    if (!(title=client->xdg->toplevel->title))
        title = broken;

    for(tags=0, rule=cfg·rule; rule != cfg·endrule; ++rule) {
        if ((!rule->title || strstr(title, rule->title)) 
         && (!rule->id    || strstr(id, rule->id))) {
            client->isfloating = rule->isfloating;
            tags |= rule->tags;
            i = 0;
            wl_list_for_each(it, &server.monitor.list, link)
                if(rule->monitor == i++)
                    monitor = it;
        }
    }

    attach(client, monitor, tags);
}