/*
 * (C)opyright MMIV-MMVI Anselm R. Garbe <garbeam at gmail dot com>
 * See LICENSE file for license details.
 */

#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <X11/Xatom.h>

#include "wm.h"

#define CLIENT_MASK		(StructureNotifyMask | PropertyChangeMask)

static Vector *
vector_of_clients(ClientVector *cv)
{
	return (Vector *) cv;
}

static void
update_client_name(Client *c)
{
	XTextProperty name;
	XGetTextProperty(dpy, c->win, &name, net_atom[NetWMName]);
	if(!name.value || !name.nitems)
		XGetTextProperty(dpy, c->win, &name, XA_WM_NAME);
	if(name.value && name.nitems) {
		if(name.encoding == XA_STRING)
			cext_strlcpy(c->name, (char *)name.value, sizeof(c->name));
		else {
			int n;
			char **list = nil;
			name.nitems = strlen((char *)name.value);
			if(Xutf8TextPropertyToTextList(dpy, &name, &list, &n) == Success
					&& n > 0 && *list)
			{
				cext_strlcpy(c->name, *list, sizeof(c->name));
				XFreeStringList(list);
			}
			else
				c->name[0] = 0;
		}
		XFree(name.value);
	}
	else
		c->name[0] = 0;
}

Client *
create_client(Window w, XWindowAttributes *wa)
{
	Client *c = (Client *) cext_emallocz(sizeof(Client));
	XSetWindowAttributes fwa;
	XClassHint ch;
	long msize;
	static unsigned int id = 1;

	c->id = id++;
	c->win = w;
	c->rect.x = wa->x;
	c->rect.y = wa->y;
	c->border = wa->border_width;
	c->rect.width = wa->width + 2 * c->border;
	c->rect.height = wa->height + 2 * c->border;
	XSetWindowBorderWidth(dpy, c->win, 0);
	c->proto = win_proto(c->win);
	XGetTransientForHint(dpy, c->win, &c->trans);
	if(!XGetWMNormalHints(dpy, c->win, &c->size, &msize) || !c->size.flags)
		c->size.flags = PSize;
	XAddToSaveSet(dpy, c->win);
	update_client_name(c);
	if(XGetClassHint(dpy, c->win, &ch)) {
		snprintf(c->classinst, sizeof(c->classinst), "%s:%s", ch.res_class,
				ch.res_name);
		XFree(ch.res_class);
		XFree(ch.res_name);
	}
	fwa.override_redirect = 1;
	fwa.background_pixmap = ParentRelative;
	fwa.event_mask = SubstructureRedirectMask | SubstructureNotifyMask
		| ExposureMask | ButtonPressMask;

	c->framewin = XCreateWindow(dpy, root, c->rect.x, c->rect.y,
			c->rect.width + 2 * def.border,
			c->rect.height + def.border + height_of_bar(), 0,
			DefaultDepth(dpy, screen), CopyFromParent,
			DefaultVisual(dpy, screen),
			CWOverrideRedirect | CWBackPixmap | CWEventMask, &fwa);
	c->gc = XCreateGC(dpy, c->framewin, 0, 0);
	XSync(dpy, False);
	cext_vattach(vector_of_clients(&client), c);
	return c;
}

void
set_client_state(Client * c, int state)
{
	long data[2];

	data[0] = (long) state;
	data[1] = (long) None;
	XChangeProperty(dpy, c->win, wm_atom[WMState], wm_atom[WMState], 32,
			PropModeReplace, (unsigned char *) data, 2);
}

void
focus_client(Client *c)
{
	Client *old = sel_client();
	Frame *f = c->frame.data[c->sel];
	View *v = f->area->view;
	int i = idx_of_area(f->area);

	v->sel = i;
	f->area->sel = idx_of_frame(f);
	if(old)
		draw_client(old);
	restack_view(v);

	XSetInputFocus(dpy, c->win, RevertToPointerRoot, CurrentTime);
	draw_client(c);
	XSync(dpy, False);
	if(i > 0 && f->area->mode == Colstack)
		arrange_column(f->area, False);
}

void
map_client(Client *c)
{
	XSelectInput(dpy, c->win, CLIENT_MASK & ~StructureNotifyMask);
	XMapWindow(dpy, c->win);
	XSelectInput(dpy, c->win, CLIENT_MASK);
	set_client_state(c, NormalState);
}

void
unmap_client(Client *c)
{
	ungrab_mouse(c->win, AnyModifier, AnyButton);
	XSelectInput(dpy, c->win, CLIENT_MASK & ~StructureNotifyMask);
	XUnmapWindow(dpy, c->win);
	XSelectInput(dpy, c->win, CLIENT_MASK);
	set_client_state(c, WithdrawnState);
}

void
reparent_client(Client *c, Window w, int x, int y)
{
	XSelectInput(dpy, c->win, CLIENT_MASK & ~StructureNotifyMask);
	XReparentWindow(dpy, c->win, w, x, y);
	XSelectInput(dpy, c->win, CLIENT_MASK);
}

void
configure_client(Client *c)
{
	XConfigureEvent e;
	Frame *f = c->frame.data[c->sel];
	e.type = ConfigureNotify;
	e.event = c->win;
	e.window = c->win;
	e.x = c->rect.x;
	e.y = c->rect.y;
	if(f) {
		e.x += f->rect.x;
		e.y += f->rect.y;
	}
	e.width = c->rect.width;
	e.height = c->rect.height;
	e.border_width = c->border;
	e.above = None;
	e.override_redirect = False;
	XSelectInput(dpy, c->win, CLIENT_MASK & ~StructureNotifyMask);
	XSendEvent(dpy, c->win, False, StructureNotifyMask, (XEvent *) & e);
	XSelectInput(dpy, c->win, CLIENT_MASK);
	XSync(dpy, False);
}

static void
send_client_message(Window w, Atom a, long value)
{
	XEvent e;
	e.type = ClientMessage;
	e.xclient.window = w;
	e.xclient.message_type = a;
	e.xclient.format = 32;
	e.xclient.data.l[0] = value;
	e.xclient.data.l[1] = CurrentTime;

	XSendEvent(dpy, w, False, NoEventMask, &e);
	XSync(dpy, False);
}

void
kill_client(Client * c)
{
	if(c->proto & WM_PROTOCOL_DELWIN)
		send_client_message(c->win, wm_atom[WMProtocols], wm_atom[WMDelete]);
	else
		XKillClient(dpy, c->win);
}

void
prop_client(Client *c, XPropertyEvent *e)
{
	long msize;

	if(e->atom == wm_atom[WMProtocols]) {
		/* update */
		c->proto = win_proto(c->win);
		return;
	}
	switch (e->atom) {
	case XA_WM_TRANSIENT_FOR:
		XGetTransientForHint(dpy, c->win, &c->trans);
		break;
	case XA_WM_NORMAL_HINTS:
		if(!XGetWMNormalHints(dpy, c->win, &c->size, &msize) || !c->size.flags) {
			c->size.flags = PSize;
		}
		break;
	}
	if(e->atom == XA_WM_NAME || e->atom == net_atom[NetWMName]) {
		update_client_name(c);
		if(c->frame.size)
			draw_client(c);
	}
}

/* speed reasoned function for client property change */
void
draw_client(Client *c)
{
	BlitzDraw d = { 0 };

	if(!c->frame.size)
		return; /* might not have been attached atm */

	d.drawable = c->framewin;
	d.font = blitzfont;
	d.gc = c->gc;

	if(c == sel_client())
		d.color = def.sel;
	else
		d.color = def.norm;

	/* draw border */
	if(def.border) {
		d.rect = c->frame.data[c->sel]->rect;
		d.rect.x = d.rect.y = 0;
		d.notch = &c->rect;
		blitz_drawlabel(dpy, &d);
		blitz_drawborder(dpy, &d);
	}
	d.rect.x = 0;
	d.rect.y = 0;
	d.rect.height = height_of_bar();
	d.notch = nil;

	/* max mode bar */
	if(c->frame.data[c->sel]->area->mode == Colmax) {
		unsigned long tmp = d.color.fg;
		char buf[256];
		d.color.fg = d.color.bg;
		d.color.bg = tmp;
		snprintf(buf, sizeof(buf), "%d/%d",
				idx_of_frame(c->frame.data[c->sel]) + 1,
				c->frame.data[c->sel]->area->frame.size);
		d.align = CENTER;
		d.rect.width = d.rect.height + XTextWidth(blitzfont.xfont, buf, strlen(buf));
		d.data = buf;
		blitz_drawlabel(dpy, &d);
		blitz_drawborder(dpy, &d);
		d.color.bg = d.color.fg;
		d.color.fg = tmp;
		d.rect.x += d.rect.width;
	}

	/* tag bar */
	d.rect.width = d.rect.height + XTextWidth(blitzfont.xfont, c->tags, strlen(c->tags));
	d.data = c->tags;
	blitz_drawlabel(dpy, &d);
	blitz_drawborder(dpy, &d);
	d.rect.x += d.rect.width;

	/* title bar */
	d.align = WEST;
	d.rect.width = c->frame.data[c->sel]->rect.width - d.rect.x;
	d.data = c->name;
	blitz_drawlabel(dpy, &d);
	blitz_drawborder(dpy, &d);

	XSync(dpy, False);
}

void
gravitate_client(Client *c, Bool invert)
{
	int dx = 0, dy = 0;
	int gravity = NorthWestGravity;

	if(c->size.flags & PWinGravity) {
		gravity = c->size.win_gravity;
	}

	/* y */
	switch (gravity) {
	case StaticGravity:
	case NorthWestGravity:
	case NorthGravity:
	case NorthEastGravity:
		dy = height_of_bar();
		break;
	case EastGravity:
	case CenterGravity:
	case WestGravity:
		dy = -(c->rect.height / 2) + height_of_bar();
		break;
	case SouthEastGravity:
	case SouthGravity:
	case SouthWestGravity:
		dy = -c->rect.height;
		break;
	default:
		break;
	}

	/* x */
	switch (gravity) {
	case StaticGravity:
	case NorthWestGravity:
	case WestGravity:
	case SouthWestGravity:
		dx = def.border;
		break;
	case NorthGravity:
	case CenterGravity:
	case SouthGravity:
		dx = -(c->rect.width / 2) + def.border;
		break;
	case NorthEastGravity:
	case EastGravity:
	case SouthEastGravity:
		dx = -(c->rect.width + def.border);
		break;
	default:
		break;
	}

	if(invert) {
		dx = -dx;
		dy = -dy;
	}
	c->rect.x += dx;
	c->rect.y += dy;
}

void
manage_client(Client *c)
{
	Client *trans;

	if(c->trans && (trans = client_of_win(c->trans)))
		cext_strlcpy(c->tags, trans->tags, sizeof(c->tags));
	else
		apply_rules(c);

	reparent_client(c, c->framewin, c->rect.x, c->rect.y);
	update_views();
}

static int
dummy_error_handler(Display *dpy, XErrorEvent *error)
{
	return 0;
}

void
destroy_client(Client *c)
{
	unsigned int i;

	XGrabServer(dpy);
	XSetErrorHandler(dummy_error_handler);

	for(i = 0; i < view.size; i++)
		detach_from_view(view.data[i], c);

	unmap_client(c);

	if(c->frame.size) {
		c->rect.x = c->frame.data[c->sel]->rect.x;
		c->rect.y = c->frame.data[c->sel]->rect.y;
	}

	reparent_client(c, root, c->rect.x, c->rect.y);
	XFreeGC(dpy, c->gc);
	XDestroyWindow(dpy, c->framewin);
	cext_vdetach(vector_of_clients(&client), c);
	update_views();
	free(c);

	XSync(dpy, False);
	XSetErrorHandler(wmii_error_handler);
	XUngrabServer(dpy);
}

Client *
sel_client()
{
	return view.size ? sel_client_of_view(view.data[sel]) : nil;
}

static void
match_sizehints(Client *c)
{
	XSizeHints *s = &c->size;

	if(s->flags & PMinSize) {
		if(c->rect.width < c->size.min_width)
			c->rect.width = c->size.min_width;
		if(c->rect.height < c->size.min_height)
			c->rect.height = c->size.min_height;
	}
	if(s->flags & PMaxSize) {
		if(c->rect.width > c->size.max_width)
			c->rect.width = c->size.max_width;
		if(c->rect.height > c->size.max_height)
			c->rect.height = c->size.max_height;
	}

	if(s->flags & PResizeInc) {
		int w = 0, h = 0;

		if(c->size.flags & PBaseSize) {
			w = c->size.base_width;
			h = c->size.base_height;
		} else if(c->size.flags & PMinSize) {
			/* base_{width,height} default to min_{width,height} */
			w = c->size.min_width;
			h = c->size.min_height;
		}
		/* client_width = base_width + i * c->size.width_inc for an integer i */
		w = c->frame.data[c->sel]->rect.width - 2 * def.border - w;
		if(s->width_inc > 0)
			c->frame.data[c->sel]->rect.width -= w % s->width_inc;

		h = c->frame.data[c->sel]->rect.height - def.border - height_of_bar() - h;
		if(s->height_inc > 0)
			c->frame.data[c->sel]->rect.height -= h % s->height_inc;
	}
}

void
resize_client(Client *c, XRectangle *r, Bool ignore_xcall)
{
	Frame *f = c->frame.data[c->sel];
	f->rect = *r;

	if((f->area->mode != Colstack) || (f->area->sel == idx_of_frame(f)))
		match_sizehints(c);

	if(!ignore_xcall) {
		if(f->area->view == view.data[sel])
			XMoveResizeWindow(dpy, c->framewin, f->rect.x,
					f->rect.y, f->rect.width, f->rect.height);
		else
			XMoveResizeWindow(dpy, c->framewin, 2 * rect.width + f->rect.x,
					f->rect.y, f->rect.width, f->rect.height);
	}

	if((f->area->mode != Colstack) || (f->area->sel == idx_of_frame(f))) {
		c->rect.x = def.border;
		c->rect.y = height_of_bar();
		c->rect.width = f->rect.width - 2 * def.border;
		c->rect.height = f->rect.height - def.border - height_of_bar();
		XMoveResizeWindow(dpy, c->win, c->rect.x, c->rect.y,
				c->rect.width, c->rect.height);
		configure_client(c);
	}
}

void
select_client(Client *c, char *arg)
{
	Frame *f = c->frame.data[c->sel];
	Area *a = f->area;
	int i = idx_of_frame(f);
	if(i == -1)
		return;
	if(!strncmp(arg, "prev", 5)) {
		if(!i)
			i = a->frame.size - 1;
		else
			i--;
	} else if(!strncmp(arg, "next", 5)) {
		if(i + 1 < a->frame.size)
			i++;
		else
			i = 0;
	}
	else {
		const char *errstr;
		i = cext_strtonum(arg, 0, a->frame.size - 1, &errstr);
		if(errstr)
			return;
	}
	focus_client(a->frame.data[i]->client);
}

void
swap_client(Client *c, char *arg)
{
	Frame *f1 = c->frame.data[c->sel], *f2;
	Area *o, *a = f1->area;
	View *v = a->view;
	int i = idx_of_area(a), j = idx_of_frame(f1);

	if(i == -1 || j == -1)
		return;

	if(!strncmp(arg, "prev", 5) && i) {
		if(i == 1)
			o = v->area.data[v->area.size - 1];
		else
			o = v->area.data[i - 1];
		goto Swaparea;
	}
	else if(!strncmp(arg, "next", 5) && i) {
		if(i < v->area.size - 1)
			o = v->area.data[i + 1];
		else
			o = v->area.data[1];
Swaparea:
		if(o == a)
			return;
		f2 = o->frame.data[o->sel];

		f1->client = f2->client;
		f2->client = c;
		f1->client->frame.data[f1->client->sel] = f1;
		f2->client->frame.data[f2->client->sel] = f2;

		arrange_column(o, False);
	}
	else if(!strncmp(arg, "up", 3) && i) {
		if(j)
			i = j - 1;
		else
			i = a->frame.size - 1;
		a->frame.data[j] = a->frame.data[i];
		a->frame.data[i] = f1;
	}
	else if(!strncmp(arg, "down", 5) && i) {
		if(j + 1 < a->frame.size)
			i = j + 1;
		else
			i = 0;
		a->frame.data[j] = a->frame.data[i];
		a->frame.data[i] = f1;
	}
	if(idx_of_area(a))
		arrange_column(a, False);
	focus_client(c);
}

void
send_client_to(Client *c, char *arg)
{
	const char *errstr;
	Frame *f = c->frame.data[c->sel];
	Area *to, *a = f->area;
	View *v = a->view;
	int i = idx_of_area(a);

	if(i == -1)
		return;

	if(!strncmp(arg, "prev", 5) && i) {
		if(i > 1)
			to = v->area.data[i - 1];
		else if(a->frame.size > 1) {
			if(!(to = new_left_column(v)))
				return;
		}
		else
			return;
	}
	else if(!strncmp(arg, "next", 5) && i) {
		if(i < v->area.size - 1)
			to = v->area.data[i + 1];
		else if(a->frame.size > 1) {
			if(!(to = new_right_column(v)))
				return;
		}
		else
			return;
	}
	else if(!strncmp(arg, "toggle", 7)) {
		if(i)
			to = v->area.data[0];
		else if(c->revert && c->revert != v->area.data[0])
			to = c->revert;
		else
			to = v->area.data[1];
	}
	else {
		i = cext_strtonum(arg, 0, v->area.size - 1, &errstr);
		if(errstr)
			return;
		to = v->area.data[i];
	}
	send_to_area(to, a, c);
}

void
resize_all_clients()
{
	unsigned int i;
	for(i = 0; i < client.size; i++) {
		Client *c = client.data[i];
		if(c->frame.size && c->frame.data[c->sel]->area) {
			if(idx_of_area(c->frame.data[c->sel]->area))
				resize_column(c, &c->frame.data[c->sel]->rect, nil);
			else
				resize_client(c, &c->frame.data[c->sel]->rect, False);
		}
	}
}

/* convenience function */
void
focus(Client *c)
{
	Frame *f = c->frame.size ? c->frame.data[c->sel] : nil;
	View *v;

	if(!f)
		return;

	v = f->area->view;
	if(view.data[sel] != v)
		focus_view(v);
	focus_client(c);
}

int
idx_of_client_id(unsigned short id)
{
	int i;
	for(i = 0; i < client.size; i++)
		if(client.data[i]->id == id)
			return i;
	return -1;
}

Client *
client_of_win(Window w)
{
	unsigned int i;

	for(i = 0; (i < client.size) && client.data[i]; i++)
		if(client.data[i]->win == w)
			return client.data[i];
	return nil;
}

void
draw_clients()
{
	unsigned int i, j;
	for(i = 0; i < client.size; i++)
		for(j = 0; j < client.data[i]->frame.size; j++)
			if(client.data[i]->frame.data[j]->area->view == view.data[sel])
				draw_client(client.data[i]);
}