/*
 * A Linux GTK+ configuration dialog.
 *
 * FIXME: Should we support command line options even with GTK+?
 */

#ifndef G_DISABLE_CAST_CHECKS
#define G_DISABLE_CAST_CHECKS
#endif

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <dlfcn.h>
#include <errno.h>
#include <locale.h>

#include <GL/glx.h>
#include <X11/extensions/xf86vmode.h>
#include <X11/keysym.h>

#include <vector>
#include <string>
#include <utility>

#include "audio/linux_alsa.h"
#include "image/image.h"
#include "linux-config.h"
#include "exception.h"

int modeline_compare(const void *a, const void *b)
{
	XF86VidModeModeInfo *am = *((XF86VidModeModeInfo **)a);
	XF86VidModeModeInfo *bm = *((XF86VidModeModeInfo **)b);

	if (am->hdisplay < bm->hdisplay) return -1;
	if (am->hdisplay == bm->hdisplay) {
		if (am->vdisplay < bm->vdisplay) return -1;
		if (am->vdisplay == bm->vdisplay) return 0;
		return 1;
	}
	return 1;
}

LinuxConfig::LinuxConfig()
{
}

/* this is largely GLADE-generated code, but modified for the dl */
void LinuxConfig::show(int *argc, char ***argv, Hashtable *attr_hash)
{
	/*
	 * open an X connection to enumerate resolutions and visuals
	 * (code duplication from glwindow.cpp, not good)
	 */
	XF86VidModeModeInfo **modes;
	Display *dpy = XOpenDisplay(NULL);
	if (dpy == NULL)
		throw new FatalException("Can't connect to X server!");
	int screen = DefaultScreen(dpy);
	
	gtk_init(argc, argv);

	GtkWidget *config;
	GtkWidget *alignment1;
	GtkWidget *vbox2;
	GtkWidget *hbox2;
	GtkWidget *pixmap1;
	GtkWidget *table2;
	GtkWidget *mode_label;
	GtkWidget *vis_label;
	GtkWidget *res_menu;
	GtkWidget *fullscreenmenu;
	GtkWidget *visualmenu;
	GtkWidget *sound_label;
	GtkWidget *soundmenu;
	GtkWidget *res_label;
	GtkWidget *spacefiller1;
	GtkWidget *spacefiller2;
	GtkWidget *hbox4;
	GtkWidget *ok;
	GdkPixbuf *gdkpixbuf;
	Image *logo;
	int w, h, bpp;
	unsigned char *ptr;
	
	config = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	g_object_set_data(G_OBJECT (config), "config", config);
	gtk_window_set_title(GTK_WINDOW (config), "Excess demo configuration (GLX/X11)");
	gtk_window_set_position(GTK_WINDOW (config), GTK_WIN_POS_CENTER);
	gtk_window_set_modal(GTK_WINDOW (config), TRUE);
	gtk_window_set_resizable(GTK_WINDOW (config), FALSE);

	alignment1 = gtk_alignment_new(0.5, 0.5, 1, 1);
	g_object_ref(alignment1);
	g_object_set_data_full(G_OBJECT (config), "alignment1", alignment1,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(alignment1);
	gtk_container_add(GTK_CONTAINER (config), alignment1);

	vbox2 = gtk_vbox_new(FALSE, 0);
	g_object_ref(vbox2);
	g_object_set_data_full(G_OBJECT (config), "vbox2", vbox2,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(vbox2);
	gtk_container_add(GTK_CONTAINER (alignment1), vbox2);

	hbox2 = gtk_hbox_new(FALSE, 10);
	g_object_ref(hbox2);
	g_object_set_data_full(G_OBJECT (config), "hbox2", hbox2,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(hbox2);
	gtk_box_pack_start(GTK_BOX (vbox2), hbox2, TRUE, TRUE, 0);
	gtk_container_set_border_width(GTK_CONTAINER (hbox2), 5);

	/* Get the logo from a PNG */
	logo = load_image("launcherlogo.png");
	w = logo->get_width();
	h = logo->get_height();
	bpp = logo->get_bpp();
	ptr = logo->get_pixel_data();
	if (bpp != 32)
		throw new NonFatalException("Launcher logo must be 32bpp");

	gdkpixbuf = gdk_pixbuf_new_from_data(ptr, GDK_COLORSPACE_RGB, TRUE, 8, w, h, w * 4, NULL, NULL);
	pixmap1 = gtk_image_new_from_pixbuf(gdkpixbuf);

	// Just leak the logo, instead of bothering with a callback.

	g_object_ref(pixmap1);
	g_object_set_data_full(G_OBJECT (config), "pixmap1", pixmap1,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(pixmap1);
	gtk_box_pack_start(GTK_BOX (hbox2), pixmap1, FALSE, TRUE, 0);

	table2 = gtk_table_new(6, 2, FALSE);
	g_object_ref(table2);
	g_object_set_data_full(G_OBJECT (config), "table2", table2,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(table2);
	gtk_box_pack_start(GTK_BOX (hbox2), table2, TRUE, FALSE, 0);
	gtk_table_set_col_spacings(GTK_TABLE (table2), 7);

	mode_label = gtk_label_new("Window mode:");
	g_object_ref(mode_label);
	g_object_set_data_full(G_OBJECT (config), "mode_label", mode_label,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(mode_label);
	gtk_table_attach(GTK_TABLE (table2), mode_label, 0, 1, 2, 3,
	                  (GtkAttachOptions) (GTK_FILL),
	                  (GtkAttachOptions) (0), 0, 0);
	gtk_label_set_justify(GTK_LABEL (mode_label), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment(GTK_MISC (mode_label), 0, 0.5);

	vis_label = gtk_label_new("OpenGL visual:");
	g_object_ref(vis_label);
	g_object_set_data_full(G_OBJECT (config), "vis_label", vis_label,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(vis_label);
	gtk_table_attach(GTK_TABLE (table2), vis_label, 0, 1, 3, 4,
	                  (GtkAttachOptions) (GTK_FILL),
	                  (GtkAttachOptions) (0), 0, 0);
	gtk_label_set_justify(GTK_LABEL (vis_label), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment(GTK_MISC (vis_label), 0, 0.5);

	res_menu = gtk_combo_box_text_new();
	g_object_ref(res_menu);
	g_object_set_data_full(G_OBJECT (config), "res_menu", res_menu,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(res_menu);
	gtk_table_attach(GTK_TABLE (table2), res_menu, 1, 2, 1, 2,
	                  (GtkAttachOptions) (GTK_FILL),
	                  (GtkAttachOptions) (0), 0, 0);

	/*
	 * enumerate through all the resolutions, then sort
	 */
	std::vector<std::pair<std::string, std::string> > resolutions;
	{
		int modeNum;
		int selected = 0;
		
		XF86VidModeGetAllModeLines(dpy, screen, &modeNum, &modes);
		qsort(modes, modeNum, sizeof(XF86VidModeModeInfo *), modeline_compare);
		
		for (int i = 0; i < modeNum; i++) {
			char buf[32];
			sprintf(buf, "%ux%u", modes[i]->hdisplay, modes[i]->vdisplay);
			gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (res_menu), buf);

			char xres[32], yres[32];
			sprintf(xres, "%u", modes[i]->hdisplay);
			sprintf(yres, "%u", modes[i]->vdisplay);
			resolutions.push_back(std::make_pair(std::string(xres), std::string(yres)));
			
			if (modes[i]->hdisplay == 640 &&
			    modes[i]->vdisplay == 480) {
				selected = i;
			}
		}
		gtk_combo_box_set_active(GTK_COMBO_BOX (res_menu), selected);

		XFree(modes);
	}
	
	fullscreenmenu = gtk_combo_box_text_new();
	g_object_ref(fullscreenmenu);
	g_object_set_data_full(G_OBJECT (config), "fullscreenmenu", fullscreenmenu,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(fullscreenmenu);
	gtk_table_attach(GTK_TABLE (table2), fullscreenmenu, 1, 2, 2, 3,
	                  (GtkAttachOptions) (GTK_FILL),
	                  (GtkAttachOptions) (0), 0, 0);

	gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (fullscreenmenu), "Fullscreen");
	gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (fullscreenmenu), "Windowed");

	gtk_combo_box_set_active(GTK_COMBO_BOX (fullscreenmenu), 0);

	/*
	 * now find all the visuals available, sort out the useless ones, and
	 * show them in the dialog
	 */
	visualmenu = gtk_combo_box_text_new();
	g_object_ref(visualmenu);
	g_object_set_data_full(G_OBJECT (config), "visualmenu", visualmenu,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(visualmenu);
	gtk_table_attach(GTK_TABLE (table2), visualmenu, 1, 2, 3, 4,
	                  (GtkAttachOptions) (GTK_FILL),
	                  (GtkAttachOptions) (0), 0, 0);

	std::vector<std::string> visual_ids;
	{
		XVisualInfo tmplate;
		int nret, usable = 0;
		int bestid = 0, bestbpp = 0, bestdepth = 0;
		
		tmplate.screen = screen;
		XVisualInfo *xvi = XGetVisualInfo(dpy, VisualScreenMask, &tmplate, &nret);
		if (xvi == NULL)
			throw new FatalException("No usable visuals!");

		for (int i = 0; i < nret; i++) {
			int has_gl, has_db, stencil_bpp, bpp, depth;
			char buf[256];

			/* first check for doublebuffered GL */
			if (glXGetConfig(dpy, &(xvi[i]), GLX_USE_GL, &has_gl) != 0 ||
			    !has_gl)
				continue;
			if (glXGetConfig(dpy, &(xvi[i]), GLX_DOUBLEBUFFER, &has_db) != 0 ||
			    !has_db)
				continue;

			/* we also need at least 4bpp stencil */
			if (glXGetConfig(dpy, &(xvi[i]), GLX_STENCIL_SIZE, &stencil_bpp) != 0 ||
			    stencil_bpp < 4)
				continue;
			
			if (glXGetConfig(dpy, &(xvi[i]), GLX_BUFFER_SIZE, &bpp) != 0)
				continue;
			if (glXGetConfig(dpy, &(xvi[i]), GLX_DEPTH_SIZE, &depth) != 0)
				continue;
		
			sprintf(buf, "%dbpp, %d-bits Z-buffer", bpp, depth);

			/*
			 * verify that there aren't already identical (for our purposes --
			 * the first usable will be selected anyhow by glXChooseVisual
			 * so we don't have to do any better guesses, I think ;-) )
			 * modes in the list... a bit ineffective, but doesn't matter either.
			 * if we really want to optimize, we could make our own array
			 * or something :-)
			 */
			bool dup = false;
			for (int j = 0; j < i; j++) {
				int has_gl2, has_db2, stencil_bpp2, bpp2, depth2;
				if (glXGetConfig(dpy, &(xvi[j]), GLX_USE_GL, &has_gl2) != 0 ||
				    !has_gl2)
					continue;
				if (glXGetConfig(dpy, &(xvi[j]), GLX_DOUBLEBUFFER, &has_db2) != 0 ||
				    !has_db2)
					continue;
				if (glXGetConfig(dpy, &(xvi[j]), GLX_STENCIL_SIZE, &stencil_bpp2) != 0 ||
				    stencil_bpp2 < 4)
					continue;
				if (glXGetConfig(dpy, &(xvi[j]), GLX_BUFFER_SIZE, &bpp2) != 0 ||
				    bpp2 != bpp)
					continue;
				if (glXGetConfig(dpy, &(xvi[j]), GLX_DEPTH_SIZE, &depth2) != 0 ||
				    depth2 != depth)
					continue;

				dup = true;
				break;
			}
			
			if (dup)
				continue;
			
			gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (visualmenu), buf);
			sprintf(buf, "%lu", xvi[i].visualid);
			visual_ids.push_back(buf);
			
			if (bpp > bestbpp || bpp == bestbpp && depth >= bestdepth) {
				bestid = usable;
				bestbpp = bpp;
				bestdepth = depth;
			}
			
			usable++;
		}
		if (usable == 0)
			throw new FatalException("No usable visuals! (Try 32bpp mode if you are not already)");
		gtk_combo_box_set_active(GTK_COMBO_BOX (visualmenu), bestid);
	}
	XCloseDisplay(dpy);

	sound_label = gtk_label_new("Sound device:");
	g_object_ref(sound_label);
	g_object_set_data_full(G_OBJECT (config), "sound_label", sound_label,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(sound_label);
	gtk_table_attach(GTK_TABLE (table2), sound_label, 0, 1, 4, 5,
	                  (GtkAttachOptions) (GTK_FILL),
	                  (GtkAttachOptions) (0), 0, 0);
	gtk_label_set_justify(GTK_LABEL (sound_label), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment(GTK_MISC (sound_label), 0, 0.5);

	soundmenu = gtk_combo_box_text_new();
	g_object_ref(soundmenu);
	g_object_set_data_full(G_OBJECT (config), "soundmenu", soundmenu,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(soundmenu);
	gtk_table_attach(GTK_TABLE (table2), soundmenu, 1, 2, 4, 5,
	                  (GtkAttachOptions) (GTK_FILL),
	                  (GtkAttachOptions) (0), 0, 0);

	std::vector<std::string> sound_paths;

	if (access("/dev/dsp", R_OK | W_OK) == 0) {
		gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (soundmenu), "OSS: Default sound device (/dev/dsp)");
		sound_paths.push_back("/dev/dsp");
	}

#if DEMOLIB_USE_ALSA
	std::vector<ALSAAudioDriver::ALSASoundCard> alsa_cards = ALSAAudioDriver::enumerate_sound_cards();
	for (unsigned i = 0; i < alsa_cards.size(); ++i) {
		gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (soundmenu), alsa_cards[i].description.c_str());
		sound_paths.push_back(alsa_cards[i].device);
	}
#endif

	gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT (soundmenu), "No sound");	
	sound_paths.push_back("");

	gtk_combo_box_set_active(GTK_COMBO_BOX (soundmenu), 0);

	res_label = gtk_label_new("Screen resolution:");
	g_object_ref(res_label);
	g_object_set_data_full(G_OBJECT (config), "res_label", res_label,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(res_label);
	gtk_table_attach(GTK_TABLE (table2), res_label, 0, 1, 1, 2,
	                  (GtkAttachOptions) (GTK_FILL),
	                  (GtkAttachOptions) (0), 0, 0);
	gtk_label_set_justify(GTK_LABEL (res_label), GTK_JUSTIFY_LEFT);
	gtk_misc_set_alignment(GTK_MISC (res_label), 0, 0.5);

	spacefiller1 = gtk_label_new("");
	g_object_ref(spacefiller1);
	g_object_set_data_full(G_OBJECT (config), "spacefiller1", spacefiller1,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(spacefiller1);
	gtk_table_attach(GTK_TABLE (table2), spacefiller1, 0, 1, 0, 1,
	                  (GtkAttachOptions) (0),
	                  (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
	gtk_misc_set_alignment(GTK_MISC (spacefiller1), 0, 0.5);

	spacefiller2 = gtk_label_new("");
	g_object_ref(spacefiller2);
	g_object_set_data_full(G_OBJECT (config), "spacefiller2", spacefiller2,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(spacefiller2);
	gtk_table_attach(GTK_TABLE (table2), spacefiller2, 0, 1, 5, 6,
	                  (GtkAttachOptions) (0),
	                  (GtkAttachOptions) (GTK_EXPAND), 0, 0);
	gtk_misc_set_alignment(GTK_MISC (spacefiller2), 0, 0.5);

	hbox4 = gtk_hbox_new(FALSE, 0);
	g_object_ref(hbox4);
	g_object_set_data_full(G_OBJECT (config), "hbox4", hbox4,
	                       (GDestroyNotify) (g_object_unref));
	gtk_widget_show(hbox4);
	gtk_box_pack_start(GTK_BOX (vbox2), hbox4, FALSE, FALSE, 0);
	gtk_container_set_border_width(GTK_CONTAINER (hbox4), 4);

	ok = gtk_button_new_with_label("Ninja!");
	g_object_ref(ok);
	g_object_set_data_full(G_OBJECT (config), "ok", ok,
	                       (GDestroyNotify) (g_object_unref));
	g_signal_connect(G_OBJECT (ok), "clicked", G_CALLBACK (gtk_main_quit), NULL);

	gtk_widget_show(ok);
	gtk_box_pack_start(GTK_BOX (hbox4), ok, TRUE, TRUE, 1);
	
	int dest_signal = g_signal_connect(G_OBJECT (config), "destroy", G_CALLBACK (exit), NULL);
	gtk_widget_show(config);
	
	gtk_main();

	/* get the parameters that were set */
	int resolution = gtk_combo_box_get_active(GTK_COMBO_BOX (res_menu));
	attr_hash->insert("xres", resolutions[resolution].first.c_str());
	attr_hash->insert("yres", resolutions[resolution].second.c_str());

	if (gtk_combo_box_get_active(GTK_COMBO_BOX (fullscreenmenu)) == 0) {	
		attr_hash->insert("fullscreen", "true");
	} else {
		attr_hash->insert("fullscreen", "false");
	}

	int visual_id = gtk_combo_box_get_active(GTK_COMBO_BOX (visualmenu));
	attr_hash->insert("visual_id", visual_ids[visual_id].c_str());

	int sound = gtk_combo_box_get_active(GTK_COMBO_BOX (soundmenu));
	attr_hash->insert("sound", sound_paths[sound].c_str());

	g_signal_handler_disconnect(G_OBJECT (config), dest_signal);
	gtk_widget_hide(config);
	gtk_widget_destroy(config);

	while (gtk_events_pending())
		gtk_main_iteration_do(false);

	setlocale(LC_ALL, "C");
}