use libui;
use libui::widget;
use libui::widget::list;
use libui::layout;
use encoding::utf8;
use io;
use fmt;
use os;
use strings;
use unix::tty;
use unix::signal;
use unix::poll;
use errors;

let u: mainUI = mainUI {...};

let searchterm: str = "";
let searchforward: bool = true;

type mainUI = struct {
	list: *list::listwidget,
};

fn sighandler(sig: int, info: *signal::siginfo, ucontext: *void) void = {
	switch (sig) {
	case signal::SIGWINCH =>
		let sz = libui::getwinsize(u.list.widget.ui)!;
		let rows: (u16 | size) = if (sz.rows - 2 < len(u.list.items)) {
			yield sz.rows - 2;
		} else {
			yield len(u.list.items);
		};
		const oldsz = list::ttysize {
			rows = u.list.sz.rows,
			cols = u.list.sz.cols,
		};
		u.list.sz.rows = rows: u16;
		u.list.sz.cols = sz.columns;
		list::resize(u.list, oldsz);
		libui::clear(u.list.widget.ui);
		list::print(u.list)!;
	case =>
		yield;
	};
};

fn resize(list: *list::listwidget) void = {
	let sz = libui::getwinsize(list.widget.ui)!;
	let rows: (u16 | size) = if (sz.rows - 2 < len(list.items)) {
		yield sz.rows - 2;
	} else {
		yield len(list.items);
	};
	const oldsz = list::ttysize {
		rows = list.sz.rows,
		cols = list.sz.cols,
	};
	list.sz.rows = rows: u16;
	list.sz.cols = sz.columns;
	list::resize(list, oldsz);
	libui::clear(list.widget.ui);
	list::print(list)!;
};

export fn main() void = {
	let in = match (io::drain(os::stdin)) {
	case let in: []u8 =>
		yield in;
	case let e: io::error =>
		fmt::fatal(io::strerror(e));
	};
	defer free(in);
	let sin = strings::fromutf8(in);
	sin = strings::trim(sin, '\n');
	let items = strings::split(sin, "\n"); // freed by list::finish
	itemscopy = strings::dupall(items);
	defer strings::freeall(itemscopy);

	let ui = libui::init();
	defer libui::finish(&ui);
	let l = list::newlist(ui, items...);
	libui::addlistener(&ui, &globalrunehandler);
	widget::addlistener(&l, &runehandler);

	let layout = layout::newlayout(&l);
	defer layout::finishall(&layout);

	//defer free(searchterm);
	libui::clear(l.widget.ui);

	match (layout::print(layout)) {
	case void =>
		yield;
	case let e: io::error =>
		fmt::fatal(io::strerror(e));
	case let e: tty::error =>
		fmt::fatal(tty::strerror(e));
	};


	signal::block(signal::SIGWINCH);
	let sfd = match (signal::signalfd(signal::SIGWINCH)) {
	case let sfd: io::file =>
		yield sfd;
	case let e: errors::error =>
		fmt::fatal(errors::strerror(e));
	};
	defer io::close(sfd)!;

	const pollfds: [2]poll::pollfd = [poll::pollfd {
		fd = ui.f,
		events = poll::event::POLLIN,
		...
	}, poll::pollfd {
		fd = sfd,
		events = poll::event::POLLIN,
		...
	}];

	for (true) {
		let nb = match (poll::poll(pollfds, poll::INDEF)) {
		case let nb: uint =>
			yield nb;
		case let e: errors::error =>
			fmt::fatal(errors::strerror(e));
		};
		let readin = false;
		if (nb == 0) {
			continue;
		} else {
			if (pollfds[0].revents & poll::event::POLLIN != 0) {
				readin = true;
			};
			if (pollfds[1].revents & poll::event::POLLIN != 0) {
				signal::read(pollfds[1].fd)!;
				resize(&l);
			};
		};
		if (readin) {
			let r = match (libui::scan(ui)) {
			case let r: rune =>
				yield r;
			case utf8::invalid =>
				fmt::fprintln(os::stderr, "Invalid utf8 sequence")!;
				break;
			case io::EOF =>
				fmt::fprintln(os::stderr, "EOF")!;
				break;
			case let e: io::error =>
				fmt::fprintln(os::stderr, io::strerror(e))!;
				break;
			};
			if (libui::notify(&ui, r)) {
				break;
			};
			if (list::notify(&l, r)) {
				break;
			};
		};
	};
};

@fini fn finish() void = {
	free(searchterm);
};