#ifdef HAVE_CONFIG_H
#  include <config.h>
#endif

#include "gsetgame.h"
#include "cards.h"
#include "bgrnd.h"
#include "debug.h"
#include "cfg.h"
#include "ui.h"


/* Prototypes */
gboolean on_configure_event (GtkWidget*, GdkEventConfigure*, gpointer);


/* Implementations */
void
on_new_event                           (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
	DBG(EVENT_DBG, "New game event\n");
	gset_game_over(GAME_ABANDONED);
	gset_new_game(cfg.default_game);
	ui_draw_playcanvas();
}

void
on_abandon_event                       (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
	DBG(EVENT_DBG, "Abandon game event\n");
	gset_game_over(GAME_ABANDONED);
	ui_draw_playcanvas();
}

void
on_prefs_event                         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
	gset_msg("Sorry. Not implemented yet.");
	DBG(EVENT_DBG, "Preferences event\n");
}

void
on_nosets_event                         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
	DBG(EVENT_DBG, "No sets left event\n");

	/* This event is only used in classic (and network?) game */	
	if ((gset_game_state() != GAME_PLAYING) || 
		(gset_game_type() != GAME_CLASSIC))
		return;

	/* Make sure there's no sets left */
	if (are_there_sets_left(&card_pack)) {
		gset_msg("There's still at least one set left. Look harder :)");
		return;
	}

	gset_game_no_sets_left();
}

void
on_hint_event                         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
	DBG(EVENT_DBG, "Hint event\n");

	/* We only give hints while playing */
	if (gset_game_state() != GAME_PLAYING)
		return;

	switch (gset_game_type()) {
		case GAME_CLASSIC:
			/* Clear card selection */
			cards_pack_reset(&card_pack);
			if (cards_pack_hint(&card_pack)) {
				/* Redraw canvas */
				ui_draw_playcanvas();
				/* Enforce user penalty for 30 seconds */
				gset_game_penalty(30);
			} else {
				gset_msg(_("No sets left"));		
			}
			break;
		case GAME_PUZZLE:
			gset_msg(_("Hints are not allowed in the puzzle game"));
			break;
		default:
			break;
	}
}

void
on_quit_event                          (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
	DBG(EVENT_DBG, "Quit event\n");
	gtk_main_quit();
	return;
}


void
on_fullscreen_event                    (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
	GdkWindowState state = gdk_window_get_state(ui.window->window);

	DBG(EVENT_DBG, "Full Screen event\n");
	if (state & GDK_WINDOW_STATE_FULLSCREEN)
	{
		gtk_window_unfullscreen((GtkWindow*)ui.window);
	}
	else
	{
		gtk_window_fullscreen((GtkWindow*)ui.window);
	}
}


void
on_about_event                         (GtkMenuItem     *menuitem,
                                        gpointer         user_data)
{
	GtkWidget *about_dlg;

	DBG(EVENT_DBG, "About event\n");

	about_dlg = glade_xml_get_widget(ui.xml, "aboutdialog");
	gtk_widget_show(about_dlg);
}


void
on_pause_event                         (GtkToolButton   *toolbutton,
                                        gpointer         user_data)
{
	DBG(EVENT_DBG, "Pause event\n");
	//gset_game_over(GAME_COMPLETED); return; // XXX REMOVEME
	gset_game_pause_toggle();
}


gboolean
on_press_event                         (GtkWidget       *widget,
                                        GdkEventButton  *event,
                                        gpointer         user_data)
{
	/* We deal with the left mouse button */
	if (event->button != 1)
		return TRUE;

	DBG(EVENT_DBG, "Press event (x,y)=(%f,%f)\n", event->x, event->y);

	switch (gset_game_state()) {
		case GAME_PLAYING:
			/* Select/deselect a card */
			if (cards_pack_check_active(&card_pack, ui.cards_image, 
				(gint)event->x, (gint)event->y)) {
				ui_draw_playcanvas();
			}

			/* Step... */
			if (gset_game_step()) {
				ui_draw_playcanvas();
			}
			break;
		case GAME_PAUSED:
			gset_game_pause_toggle();
			break;
		case GAME_ABANDONED:	
		case GAME_COMPLETED:
			gset_new_game(cfg.default_game);
			ui_draw_playcanvas();
			break;
		default:
			break;
	}
	return FALSE;
}

#if 0
gboolean
on_motion_notify_event                 (GtkWidget       *widget,
                                        GdkEventMotion  *event,
                                        gpointer         user_data)
{
	DBG(EVENT_DBG, "Motion notify event is not used here\n");
	return FALSE;
}
#endif

gboolean
on_expose_event                        (GtkWidget       *widget,
                                        GdkEventExpose  *event,
                                        gpointer         user_data)
{
	DBG(EVENT_DBG, "Expose event\n");

	if (ui.backbuffer == NULL)
		on_configure_event(widget, NULL, NULL);
	
	/* Draw the exposed part from the background buffer to the screen */
	gdk_draw_drawable(widget->window, widget->style->black_gc,
		ui.backbuffer, event->area.x, event->area.y,
		event->area.x, event->area.y,
		event->area.width, event->area.height);

  return FALSE;
}


gboolean
on_configure_event                     (GtkWidget       *widget,
                                        GdkEventConfigure *event,
                                        gpointer         user_data)
{
	gint width, height; 

	width = widget->allocation.width;
	height = widget->allocation.height;

	DBG(EVENT_DBG, "Configure event: w=%d, h=%d\n", width, height);

	/* Remove the existing background buffer */
	if (ui.backbuffer)
		g_object_unref(ui.backbuffer);
	
	if (ui.backbuffer_gc)
		g_object_unref(ui.backbuffer_gc);
	
	/* Create a new buffer and GC */
	ui.backbuffer = gdk_pixmap_new(widget->window,
		width,
		height,
		-1);
	ui.backbuffer_gc = gdk_gc_new(ui.backbuffer);

	/* Resize background and cards */
	bgrnd_flush(FALSE);
	cards_pack_resize_cards(&card_pack, ui.cards_image, width, height);

	ui_draw_playcanvas();

	return TRUE;
}