/*
 *  Copyright Geoff Levand <geoff@infradead.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#if defined(HAVE_CONFIG_H)
#include "config.h"
#endif

#define _GNU_SOURCE
#include <assert.h>
#include <string.h>
#include <linux/input.h>

#include "log/log.h"
#include "talloc/talloc.h"
#include "ui/common/ui-system.h"

#include "pbt-menu.h"

static void pbt_item_draw_cb(twin_window_t *window)
{
	struct pbt_item *item = pbt_item_from_window(window);
	twin_pixmap_t *image;

	assert(window == item->window);

	pbt_dump_item(item);

	//pbt_dump_pixmap(window->pixmap);

	if (pbt_item_is_selected(item) && item->menu->has_focus)
		image = item->pixmap_active;
	else if (pbt_item_is_selected(item) && !item->menu->has_focus)
		image = item->pixmap_selected;
	else
		image = item->pixmap_idle;

	pbt_image_draw(window->pixmap, image);
}

static twin_bool_t pbt_item_event_cb(twin_window_t *window,
	twin_event_t *event)
{
	struct pbt_item *item = pbt_item_from_window(window);

	pbt_dump_event(pbt_item_name(item), window, event);

	switch(event->kind) {
	case TwinEventButtonDown:
		if (item->on_execute)
			item->on_execute(item);
		break;
	case TwinEventButtonUp:
		break;
	case TwinEventMotion:
		/* prevent window drag */
		return TWIN_TRUE;
	case TwinEventEnter:
		pbt_item_set_as_selected(item);
		break;
	case TwinEventLeave:
		break;
	case TwinEventKeyDown:
		switch(event->u.key.key) {
		case (twin_keysym_t)XK_Return:
		case (twin_keysym_t)KEY_ENTER:
			if (item->on_execute)
				item->on_execute(item);
			break;
		case (twin_keysym_t)'e':
			if (item->on_edit)
				item->on_edit(item);
			break;
		default:
			break;
		}
		break;
	default:
		break;
	}
	return TWIN_FALSE;
}

int pbt_item_editor(struct pbt_item *item)
{
	(void)item;
	return -1;
}

struct pbt_item *pbt_item_create(struct pbt_menu *menu, const char *name,
	unsigned int position, const char *icon_filename, const char *title,
	const char *text)
{
	struct pbt_quad q;
	struct pbt_item *item;
	twin_pixmap_t *icon;
	twin_operand_t src;
	const struct pbt_menu_layout *layout = &menu->layout;
	twin_path_t *path;
	static const twin_argb32_t focus_color = 0x10404040;
	enum {
		corner_rounding = 8,
		stroke_width = 2,
	};

	assert(menu);

	DBGS("%d:%s (%s)\n", position, name, icon_filename);

	item = talloc_zero(menu, struct pbt_item);

	if (!item)
		return NULL;

	item->menu = menu;
	item->on_edit = pbt_item_editor;

	pbt_menu_get_item_quad(menu, position, &q);

	item->window = twin_window_create(menu->scr->tscreen,
		TWIN_ARGB32, TwinWindowPlain,
		q.x, q.y, q.width, q.height);

	if (!item->window)
		goto fail_window_create;

	twin_window_set_name(item->window, name);
	item->window->client_data = item;
	item->window->draw = pbt_item_draw_cb;
	item->window->event = pbt_item_event_cb;

	item->pixmap_idle = twin_pixmap_create(TWIN_ARGB32, q.width, q.height);
	assert(item->pixmap_idle);

	item->pixmap_selected = twin_pixmap_create(TWIN_ARGB32, q.width,
		q.height);
	assert(item->pixmap_selected);

	item->pixmap_active = twin_pixmap_create(TWIN_ARGB32, q.width,
		q.height);
	assert(item->pixmap_active);

	if (!item->pixmap_idle || !item->pixmap_selected || !item->pixmap_active)
		goto fail_pixmap_create;

	twin_fill(item->pixmap_idle, 0x01000000, TWIN_SOURCE, 0, 0, q.width,
		q.height);

	/* Add item icon */

	icon = pbt_icon_load(icon_filename);

	if (!icon)
		goto fail_icon;

	src.source_kind = TWIN_PIXMAP;
	src.u.pixmap = icon;

	twin_composite(item->pixmap_idle,
		//0, (item->pixmap_idle->height - icon->height) / 2,
		0, 0,
		&src, 0, 0,
		NULL, 0, 0,
		TWIN_SOURCE,
		icon->width, icon->height);

	/* Add item text */

	path = twin_path_create();
	assert(path);

	if (title) {
		twin_path_set_font_size(path,
			twin_int_to_fixed(layout->title.font_size));
		twin_path_set_font_style(path, TWIN_TEXT_UNHINTED);

		twin_path_move(path,
			twin_int_to_fixed(icon->width + layout->text_space),
			twin_int_to_fixed(layout->title.font_size
				+ layout->text_space));
		twin_path_utf8(path, title);
		twin_paint_path(item->pixmap_idle, layout->title.color, path);
		twin_path_empty(path);
	}

	if (text) {
		twin_path_set_font_size(path,
			twin_int_to_fixed(layout->text.font_size));
		twin_path_move(path,
			twin_int_to_fixed(icon->width + layout->text_space),
			twin_int_to_fixed(layout->title.font_size
				+ layout->text.font_size
				+ layout->text_space));
		twin_path_utf8(path, text);
		twin_paint_path(item->pixmap_idle, layout->text.color, path);
		twin_path_empty(path);
	}

	pbt_image_draw(item->pixmap_selected, item->pixmap_idle);
	pbt_image_draw(item->pixmap_active, item->pixmap_idle);

if (0) {
	static const struct pbt_border grey_border = {
		.right = 1,
		.left = 1,
		.top = 1,
		.bottom = 1,
		.fill_color = 0xffe0e0e0,
	};

	//pbt_border_draw(item->pixmap_idle, &pbt_blue_debug_border);
	pbt_border_draw(item->pixmap_selected, &grey_border);
	pbt_border_draw(item->pixmap_active, &pbt_green_debug_border);
} else {
	assert(!(stroke_width % 2));

	/* pixmap_selected */

	twin_path_rounded_rectangle(path,
		twin_int_to_fixed(stroke_width / 2),
		twin_int_to_fixed(stroke_width / 2),
		twin_int_to_fixed(item->pixmap_selected->width - stroke_width),
		twin_int_to_fixed(item->pixmap_selected->height - stroke_width),
		twin_int_to_fixed(corner_rounding),
		twin_int_to_fixed(corner_rounding));

	twin_paint_stroke(item->pixmap_selected, focus_color, path,
		twin_int_to_fixed(stroke_width));

	twin_path_empty(path);

	/* pixmap_active */

	twin_path_rounded_rectangle(path, 0, 0,
		twin_int_to_fixed(item->pixmap_active->width),
		twin_int_to_fixed(item->pixmap_active->height),
		twin_int_to_fixed(corner_rounding),
		twin_int_to_fixed(corner_rounding));

	twin_paint_path(item->pixmap_active, focus_color, path);

	twin_path_empty(path); // FIXME: need it???
}
	twin_path_destroy(path);

	list_add_tail(menu->item_list, &item->list);

	pbt_item_redraw(item);

	return item;

fail_window_create:
fail_pixmap_create:
fail_icon:
	return NULL;
}

void _pbt_dump_item(const struct pbt_item* item, const char *func, int line)
{
	DBG("%s:%d: %p: %sselected, %sfocus\n", func, line, item,
		(pbt_item_is_selected(item) ? "+" : "-"),
		(item->menu->has_focus ? "+" : "-"));
}

/**
 * pbt_menu_get_item_quad - Return item coords relative to screen origin.
 */

struct pbt_quad *pbt_menu_get_item_quad(const struct pbt_menu *menu,
	unsigned int pos, struct pbt_quad *q)
{
	const struct pbt_menu_layout *layout = &menu->layout;

	q->x = menu->window->pixmap->x + layout->item_space;

	q->width = menu->window->pixmap->width - 2 * layout->item_space;

	q->y = menu->window->pixmap->y + layout->item_space
		+ pos * (layout->item_height + layout->item_space);

	q->height = layout->item_height;

	return q;
}

static void pbt_menu_draw_cb(twin_window_t *window)
{
	struct pbt_menu *menu = pbt_menu_from_window(window);
	twin_path_t *path = twin_path_create();

	assert(path);

	pbt_dump_pixmap(window->pixmap);

	twin_fill(window->pixmap, menu->background_color, TWIN_SOURCE,
		0, 0, window->pixmap->width, window->pixmap->height);

	pbt_border_draw(window->pixmap, &menu->border);

	twin_path_destroy(path);
}

static twin_bool_t pbt_menu_event_cb(twin_window_t *window,
	twin_event_t *event)
{
	struct pbt_menu *menu = pbt_menu_from_window(window);
	struct pbt_item *i;

	pbt_dump_event(pbt_menu_name(menu), window, event);

	switch(event->kind) {
	case TwinEventButtonDown:
	case TwinEventButtonUp:
	case TwinEventMotion:
		/* prevent window drag */
		return TWIN_TRUE;
	case TwinEventEnter:
		pbt_menu_set_focus(menu, 1);
		break;
	case TwinEventLeave:
		if (!pbt_window_contains(window, event))
			pbt_menu_set_focus(menu, 0);
		break;
	case TwinEventKeyDown:
		switch(event->u.key.key) {
		case (twin_keysym_t)XK_Up:
		case (twin_keysym_t)KEY_UP:
			i = list_prev_entry(menu->item_list, menu->selected,
				list);
			if (i)
				pbt_item_set_as_selected(i);
			break;
		case (twin_keysym_t)XK_Down:
		case (twin_keysym_t)KEY_DOWN:
			i = list_next_entry(menu->item_list, menu->selected,
				list);
			if (i)
				pbt_item_set_as_selected(i);
			break;
		case (twin_keysym_t)XK_Left:
		case (twin_keysym_t)KEY_LEFT:
			if (menu->parent) {
				pbt_menu_set_focus(menu, 0);
				pbt_menu_set_focus(menu->parent, 1);
			} else
				DBGS("no parent\n");
			break;
		case (twin_keysym_t)XK_Right:
		case (twin_keysym_t)KEY_RIGHT:
			if (menu->selected->sub_menu) {
				pbt_menu_set_focus(menu, 0);
				pbt_menu_set_focus(menu->selected->sub_menu, 1);
			} else
				DBGS("no sub_menu\n");
			break;
		default:
			return pbt_item_event_cb(menu->selected->window, event);
		}
		break;
	default:
		break;
	}
	return TWIN_FALSE;
}

struct pbt_menu *pbt_menu_create(void *talloc_ctx, const char *name,
	struct pbt_scr *scr, struct pbt_menu *parent, const struct pbt_quad *q,
	const struct pbt_menu_layout *layout)
{
	struct pbt_menu *menu;

	assert(scr);

	DBGS("%s\n", name);

	menu = talloc_zero(talloc_ctx, struct pbt_menu);

	if (!menu)
		return NULL;

	menu->scr = scr;
	menu->parent = parent;
	menu->layout = *layout;

	menu->item_list = talloc(menu, struct list);
	list_init(menu->item_list);

	menu->window = twin_window_create(scr->tscreen, TWIN_ARGB32,
		TwinWindowPlain, q->x, q->y,
		q->width, q->height);

	if (!menu->window)
		goto fail_window;

	DBGS("window = %p\n", menu->window);

	twin_window_set_name(menu->window, name);

	menu->background_color = 0x01000000; //FIXME: what value???

	menu->window->draw = pbt_menu_draw_cb;
	menu->window->event = pbt_menu_event_cb;
	menu->window->client_data = menu;

	pbt_dump_pixmap(menu->window->pixmap);

	pbt_menu_redraw(menu);

	return menu;

fail_window:
	assert(0);
	talloc_free(menu);
	return NULL;
}

void pbt_menu_set_focus(struct pbt_menu *menu, int focus)
{
	DBGS("%s(%p): %d -> %d\n", pbt_menu_name(menu), menu, menu->has_focus,
		focus);

	assert(menu->selected);

	if (!menu->has_focus == !focus)
		return;

	menu->has_focus = !!focus;

	/* Route key events to menu with focus. */

	if (menu->has_focus)
		menu->scr->tscreen->active = menu->window->pixmap;

	pbt_item_redraw(menu->selected);
}

void pbt_menu_hide(struct pbt_menu *menu)
{
	struct pbt_item *item;

	if (!menu)
		return;

	list_for_each_entry(menu->item_list, item, list) {
		if (item->sub_menu)
			pbt_menu_hide(item->sub_menu);

		twin_window_hide(item->window);
		//twin_window_queue_paint(item->window);
	}

	twin_window_hide(menu->window);
	//twin_window_queue_paint(menu->window);
}

void pbt_menu_show(struct pbt_menu *menu, int hide)
{
	struct pbt_item *item;

	if (!menu)
		return;

	twin_window_show(menu->window);
	pbt_menu_redraw(menu);

	list_for_each_entry(menu->item_list, item, list) {
		twin_window_show(item->window);
		pbt_item_redraw(item);

		if (item->sub_menu) {
			if (pbt_item_is_selected(item))
				pbt_menu_show(item->sub_menu, hide);
			else if (hide)
				pbt_menu_hide(item->sub_menu);
		}
	}
}

void pbt_menu_set_selected(struct pbt_menu *menu, struct pbt_item *item)
{
	struct pbt_item *last_selected;

	assert(item);

	DBGS("%s(%p): %s(%p) -> %s(%p)\n", pbt_menu_name(menu), menu,
		(menu->selected ? pbt_menu_name(menu) : "none"),
		menu->selected, pbt_item_name(item), item);

	if (menu->selected == item)
		return;

	last_selected = menu->selected;
	menu->selected = item;

	if (last_selected) {
		pbt_menu_hide(last_selected->sub_menu);
		pbt_item_redraw(last_selected);
	}

	pbt_item_redraw(item);
	pbt_menu_show(item->sub_menu, 0);
}