#include <u.h>
#include <libc.h>
#include <bio.h>
#include <fcall.h>
#include <draw.h>
#include <memdraw.h>
#include <keyboard.h>
#include <event.h>
#include <nuklear.h>

typedef struct Imagegrid Imagegrid;
typedef struct NImg NImg;

enum {
	Ekbd	= Ekeyboard<<1,
	Etimer	= Ekbd<<1,
};

struct Imagegrid
{
	int nrow;
	int ncol;
	Rectangle r;
};

struct NImg
{
	Image *img;
	char *name;
};

int fflag = 0;


static Image*
getimage(char *file)
{
	int fd;
	Image *i;

	if((fd = open(file, OREAD)) < 0)
		return nil;

	i = readimage(display, fd, 0);
	close(fd);
	return i;
}

static Imagegrid
createtable(NImg *images, int nimg)
{
	int i, screenx, deltasize;

	Point min = {0, 0};
	Point max = {0, 0};
	Rectangle r = {min, max};
	Imagegrid ig = {1 , 0, r};

	screenx = Dx(screen->r);
	for(i=0; i < nimg; i++){
		deltasize = (images+i)->img->r.max.x + 15;
		if(screenx < max.x + deltasize){
			max.x = 0;
			ig.nrow++;
		}
		max.x += deltasize;
		max.y += (images+i)->img->r.max.y + 15;
	}
	ig.ncol = nimg / ig.nrow;
	return ig;
}


static void
nitro(struct nk_context *ctx, NImg *images, int nimg)
{
	static struct nk_rect r;
	struct nk_image nkimg;
	int i, j, index;
	Imagegrid ig;
	
	ig = createtable(images, nimg);
	if(nk_begin_titled(ctx, "nitro", "Nitro", nk_rect(0, 0, Dx(screen->r),Dy(screen->r)),0)){
		for(i=0; i < ig.nrow; i++){
			nk_layout_row_dynamic(ctx, Dy(screen->r) / ig.nrow, ig.ncol);
			for(j=0; j<ig.ncol; j++){
				index = j + (i * ig.ncol);
				nkimg = nk_image_ptr(images[index].img);
				if(nk_button_image(ctx, nkimg)){
						fprint(1, "%s\n" , images[index].name);
						exits(nil);
					}
			}
		}
	}
	nk_end(ctx);
}

static int
thumbs(NImg **buffer, char* dir)
{
	Dir *db;
	int fd;
	long n;
	int i;
	char namebuf[4096];

	db = dirstat(dir);
	if(db == nil)
		sysfatal("Could not find thumbs");
	
	n = 0;
	if((db->qid.type&QTDIR)){
		free(db);
		fd = open(dir, OREAD);
		n = dirreadall(fd, &db);
		*buffer=(NImg*)realloc(*buffer, n*sizeof(NImg));
		for(i=0; i<n; i++){
			sprint(namebuf, "%s/%s", dir, (db+i)->name);
			(*buffer+i)->img = getimage(namebuf);
			(*buffer+i)->name = strdup(fflag ? (db+i)->name : namebuf);
		}
	}
	return n;
}

void
usage(void)
{
	fprint(2, "usage: %s [[ dir ]]\n", argv0);
	exits("usage");
}

void
main(int argc, char *argv[])
{
	int kbdfd;
	Event e;
	struct nk_user_font nkfont;
	struct nk_context sctx;
	struct nk_context *ctx = &sctx;
	NImg *images;
	int nimg;
	char *dir;


	ARGBEGIN{
	case 'f': fflag++; break;
	default:
		usage();
	}ARGEND
	
	if(! *argv)
		usage();

	dir = *argv;

	/* open kbd for up/down events */
	if((kbdfd = open("/dev/kbd", OREAD)) < 0)
		sysfatal("open: %r");

	if(initdraw(nil, nil, "nitro") < 0)
		sysfatal("initdraw: %r");

	/* need mouse, keyboard, and timer */
	einit(Emouse);
	estart(Ekbd, kbdfd, EMAXMSG);
	etimer(Etimer, 100);

	/* create nuklear font from default libdraw font */
	nk_plan9_makefont(&nkfont, font);

	/* initialize nuklear */
	if(!nk_init_default(ctx, &nkfont))
		sysfatal("nk_init: %r");
	images=(NImg*)malloc(sizeof(NImg));
	nimg = thumbs(&images, dir);

	static int firstdraw = 1;

	for(;;){
		/* skip initial timer delay */
		if(firstdraw){
			firstdraw = 0;
			goto draw;
		}

		/* begin input handling block */
		nk_input_begin(ctx);

		switch(event(&e)){
		case Emouse:
			nk_plan9_handle_mouse(ctx, e.mouse, screen->r.min);
			break;

		case Ekbd:
			nk_plan9_handle_kbd(ctx, (char*)e.data, e.n);
			break;

		case Etimer:
			break;
		}

		nk_input_end(ctx);
		/* end input handling block */

		/* handle usual plan 9 exit key */
		if(nk_input_is_key_down(&ctx->input, NK_KEY_DEL))
			exits(nil);

draw:
		nitro(ctx, images, nimg);

		/* render everything */
		draw(screen, screen->r, display->black, nil, ZP);
		nk_plan9_render(ctx, screen);
		flushimage(display, 1);
	}
}

void 
eresized(int new)
{
	if(new && getwindow(display, Refnone) < 0) {
		sysfatal("getwindow: %r");
	}
//	nk_plan9_resized(new);
}