/*

 * (C)opyright MMVI Anselm R. Garbe <garbeam at gmail dot com>

 * (C)opyright MMVI Sander van Dijk <a dot h dot vandijk at gmail dot com>

 * See LICENSE file for license details.

 */

#include "config.h"

#include "draw.h"

#include "util.h"

#include <ctype.h>

#include <stdlib.h>

#include <stdio.h>

#include <string.h>

#include <sys/stat.h>

#include <sys/wait.h>

#include <time.h>

#include <unistd.h>

#include <X11/cursorfont.h>

#include <X11/Xutil.h>

#include <X11/keysym.h>

typedef struct Item Item;

struct Item {

	Item *next;		/* traverses all items */

	Item *left, *right;	/* traverses items matching current search pattern */

	char *text;

};

static Display *dpy;

static Window root;

static Window win;

static Bool done = False;

static Item *allitem = NULL;	/* first of all items */

static Item *item = NULL;	/* first of pattern matching items */

static Item *sel = NULL;

static Item *nextoff = NULL;

static Item *prevoff = NULL;

static Item *curroff = NULL;

static char *title = NULL;

static char text[4096];

static int ret = 0;

static int nitem = 0;

static unsigned int cmdw = 0;

static const int seek = 30;		/* 30px */

static Brush brush = {0};

static void draw_menu();

static void kpress(XKeyEvent * e);

static char version[] = "gridmenu - " VERSION ", (C)opyright MMVI Anselm R. Garbe\n";

static void

usage()

{

	fprintf(stderr, "%s", "usage: gridmenu [-v] [-t <title>]\n");

	exit(1);

}

static void

update_offsets()

{

	unsigned int tw, w = cmdw + 2 * seek;

	if(!curroff)

		return;

	for(nextoff = curroff; nextoff; nextoff=nextoff->right) {

		w += tw + brush.font.height;

			break;

	}

	w = cmdw + 2 * seek;

	for(prevoff = curroff; prevoff && prevoff->left; prevoff=prevoff->left) {

		w += tw + brush.font.height;

			break;

	}

}

static void

update_items(char *pattern)

{

	unsigned int plen = strlen(pattern);

	Item *i, *j;

	if(!pattern)

		return;

	if(!title || *pattern)

	else

	item = j = NULL;

	nitem = 0;

	for(i = allitem; i; i=i->next)

		if(!plen || !strncmp(pattern, i->text, plen)) {

			if(!j)

				item = i;

			else

				j->right = i;

			i->left = j;

			i->right = NULL;

			j = i;

			nitem++;

		}

	for(i = allitem; i; i=i->next)

		if(plen && strncmp(pattern, i->text, plen)

				&& strstr(i->text, pattern)) {

			if(!j)

				item = i;

			else

				j->right = i;

			i->left = j;

			i->right = NULL;

			j = i;

			nitem++;

		}

	curroff = prevoff = nextoff = sel = item;

	update_offsets();

}

/* creates brush structs for brush mode drawing */

static void

draw_menu()

{

	Item *i;

	draw(dpy, &brush, False, 0);

	/* print command */

	if(!title || text[0]) {

		if(cmdw && item)

		draw(dpy, &brush, False, text);

	}

	else {

		draw(dpy, &brush, False, title);

	}

	if(curroff) {

		draw(dpy, &brush, False, (curroff && curroff->left) ? "<" : 0);

		/* determine maximum items */

		for(i = curroff; i != nextoff; i=i->right) {

			brush.border = False;

			if(sel == i) {

				swap((void **)&brush.fg, (void **)&brush.bg);

				draw(dpy, &brush, True, i->text);

				swap((void **)&brush.fg, (void **)&brush.bg);

			}

			else

				draw(dpy, &brush, False, i->text);

		}

		draw(dpy, &brush, False, nextoff ? ">" : 0);

	}

	XFlush(dpy);

}

static void

kpress(XKeyEvent * e)

{

	KeySym ksym;

	char buf[32];

	int num, prev_nitem;

	unsigned int i, len = strlen(text);

	buf[0] = 0;

	num = XLookupString(e, buf, sizeof(buf), &ksym, 0);

	if(IsFunctionKey(ksym) || IsKeypadKey(ksym)

			|| IsMiscFunctionKey(ksym) || IsPFKey(ksym)

			|| IsPrivateKeypadKey(ksym))

		return;

	/* first check if a control mask is omitted */

	if(e->state & ControlMask) {

		switch (ksym) {

		case XK_H:

		case XK_h:

			ksym = XK_BackSpace;

			break;

		case XK_I:

		case XK_i:

			ksym = XK_Tab;

			break;

		case XK_J:

		case XK_j:

			ksym = XK_Return;

			break;

		case XK_N:

		case XK_n:

			ksym = XK_Right;

			break;

		case XK_P:

		case XK_p:

			ksym = XK_Left;

			break;

		case XK_U:

		case XK_u:

			text[0] = 0;

			update_items(text);

			draw_menu();

			return;

			break;

		case XK_bracketleft:

			ksym = XK_Escape;

			break;

		default:	/* ignore other control sequences */

			return;

			break;

		}

	}

	switch (ksym) {

	case XK_Left:

		if(!(sel && sel->left))

			return;

		sel=sel->left;

		if(sel->right == curroff) {

			curroff = prevoff;

			update_offsets();

		}

		break;

	case XK_Tab:

		if(!sel)

			return;

		strncpy(text, sel->text, sizeof(text));

		update_items(text);

		break;

	case XK_Right:

		if(!(sel && sel->right))

			return;

		sel=sel->right;

		if(sel == nextoff) {

			curroff = nextoff;

			update_offsets();

		}

		break;

	case XK_Return:

		if(e->state & ShiftMask) {

			if(text)

				fprintf(stdout, "%s", text);

		}

		else if(sel)

			fprintf(stdout, "%s", sel->text);

		else if(text)

			fprintf(stdout, "%s", text);

		fflush(stdout);

		done = True;

		break;

	case XK_Escape:

		ret = 1;

		done = True;

		break;

	case XK_BackSpace:

		if((i = len)) {

			prev_nitem = nitem;

			do {

				text[--i] = 0;

				update_items(text);

			} while(i && nitem && prev_nitem == nitem);

			update_items(text);

		}

		break;

	default:

		if(num && !iscntrl((int) buf[0])) {

			buf[num] = 0;

			if(len > 0)

				strncat(text, buf, sizeof(text));

			else

				strncpy(text, buf, sizeof(text));

			update_items(text);

		}

	}

	draw_menu();

}

static char *

read_allitems()

{

	static char *maxname = NULL;

	char *p, buf[1024];

	unsigned int len = 0, max = 0;

	Item *i, *new;

	i = 0;

	while(fgets(buf, sizeof(buf), stdin)) {

		len = strlen(buf);

		if (buf[len - 1] == '\n')

			buf[len - 1] = 0;

		p = estrdup(buf);

		if(max < len) {

			maxname = p;

			max = len;

		}

		new = emalloc(sizeof(Item));

		new->next = new->left = new->right = NULL;

		new->text = p;

		if(!i)

			allitem = new;

		else 

			i->next = new;

		i = new;

	}

	return maxname;

}

int

main(int argc, char *argv[])

{

	int i;

	XSetWindowAttributes wa;

	char *maxname;

	XEvent ev;