#include <gtk/gtk.h>
#include "../splash.xpm"
#include "../icon.xpm"

#include <dirent.h> 
#include <stdio.h>
#include <pwd.h>

typedef unsigned char byte;

static char cmd_args[128];

static char engine_game[16];
static int engine_memory;
static int engine_vid_width;
static int engine_vid_height;
static byte engine_vid_border;
static byte engine_hidden;
static char engine_cfg_path[80];
static int iGameCnt;

void launcher_settings_save()
{
	FILE *fFile;
	fFile = fopen(engine_cfg_path, "w+");

	fprintf(fFile, "%d\n", engine_memory);
	fprintf(fFile, "%d\n", engine_vid_width);
	fprintf(fFile, "%d\n", engine_vid_height);
	fprintf(fFile, "%d\n", engine_vid_border);
	fprintf(fFile, "%d\n", engine_hidden);
	fclose(fFile);
	printf("[LAUNCHER] Saved settings...\n");
}

void launcher_settings_load()
{
	FILE *fFile;
	uid_t uid = getuid();
        struct passwd *pw = getpwuid(uid);
	sprintf(engine_cfg_path, "%s/.ngunixrc", pw->pw_dir);

	if(access(engine_cfg_path, R_OK) != -1 ) 
	{
		fFile = fopen(engine_cfg_path, "r");
		fscanf(fFile,"%d %d %d %d %d", &engine_memory, &engine_vid_width, &engine_vid_height, &engine_vid_border, &engine_hidden);
		fclose(fFile);
		printf("[LAUNCHER] Loaded settings... %dx%d @ %dMB memory\n", engine_vid_width, engine_vid_height, engine_memory);
	} 
	else 
	{
		engine_memory 		= 60;
		engine_vid_width 	= 640;
		engine_vid_height 	= 480;
		engine_vid_border 	= 1;
		engine_hidden 		= 1;
		launcher_settings_save();
	}
}

enum 
{
	LIST_ITEM,
	LIST_DIR,
	N_COLUMNS
};

void launcher_init_list(GtkWidget *list)
{
  	GtkCellRenderer *renderer1;
	GtkCellRenderer *renderer2;
  	GtkTreeViewColumn *column1, *column2;
  	GtkListStore *store;

  	renderer1 = gtk_cell_renderer_text_new ();
  	column1 = gtk_tree_view_column_new_with_attributes("Game", renderer1, "text", LIST_ITEM, NULL);
	gtk_tree_view_column_set_sort_column_id (column1, LIST_ITEM);
	gtk_tree_view_column_set_expand(column1, TRUE);

	renderer2 = gtk_cell_renderer_text_new ();
  	column2 = gtk_tree_view_column_new_with_attributes("Directory", renderer1, "text", LIST_DIR, NULL);
	gtk_tree_view_column_set_sort_column_id (column2, LIST_DIR);
	gtk_tree_view_column_set_expand(column1, TRUE);

  	gtk_tree_view_append_column(GTK_TREE_VIEW(list), column1);
	gtk_tree_view_append_column(GTK_TREE_VIEW(list), column2);
	store = gtk_list_store_new(N_COLUMNS, G_TYPE_STRING, G_TYPE_STRING);

  	gtk_tree_view_set_model(GTK_TREE_VIEW(list), GTK_TREE_MODEL(store));
	g_object_unref(store);
}

void launcher_add_to_list(GtkWidget *list, const gchar *gcTitle, const gchar *gcDir)
{
  	GtkListStore *store;
  	GtkTreeIter iter;

  	store = GTK_LIST_STORE(gtk_tree_view_get_model(GTK_TREE_VIEW(list)));

	gtk_list_store_append(store, &iter);
	gtk_list_store_set(store, &iter, LIST_ITEM, gcTitle, -1);
	gtk_list_store_set(store, &iter, LIST_DIR, gcDir, -1);
}

void launcher_list_changed(GtkWidget *widget, gpointer label) 
{
	GtkTreeModel *model;
	GtkTreeIter iter;
	gchar *value;

	if (gtk_tree_selection_get_selected(GTK_TREE_SELECTION(widget), &model, &iter)) 
	{
    		gtk_tree_model_get(model, &iter, LIST_DIR, &value,  -1);
		sprintf(engine_game, "%s", value);
    		g_free(value);
  	}
}

void launcher_cachefolders(GtkWidget *list)
{
	DIR  *d;
	FILE *f;
  	struct dirent *dir;
	char cFile[32];
	
  	d = opendir(".");

  	if (d)
  	{
    		while ((dir = readdir(d)) != NULL)
    		{
			if (dir->d_type == DT_DIR && !(strcmp(dir->d_name, ".") == 0 || strcmp(dir->d_name, "..") == 0))
			{
				sprintf(cFile, "./%s/info", dir->d_name);

				if(access(cFile, R_OK) != -1 )
				{	
					f = fopen(cFile, "r");
					char cTemp[64];
					fscanf(f, "%63[^\n]", cTemp);
					fclose(f);
      					printf("           Found %s (%s)\n", cTemp, dir->d_name);
					launcher_add_to_list(list, cTemp, dir->d_name);
					iGameCnt++;
				}
				else if(engine_hidden == 0)
					launcher_add_to_list(list, dir->d_name, dir->d_name);
			}
    		}
    		closedir(d);
  	}
}

void launcher_start()
{
	char cmd[128];
	char cbase[64];
	char cFile[32];
	char cArgs[64];

	sprintf(cFile, "./%s/cmdline", engine_game);
	if(access(cFile, R_OK) != -1 )
	{	
		FILE *f;
		f = fopen(cFile, "r");
		fscanf(f, "%63[^\n]", cArgs);
		fclose(f);
	}
	else
		sprintf(cArgs, "");

	sprintf(cbase, "./ngunix.x11 -data id1 -winsize %d %d -mem %d", engine_vid_width, engine_vid_height, engine_memory);

	if(engine_vid_border == 1)
		sprintf(cmd, "%s -game %s %s\n", cbase, engine_game, cArgs);
	else
		sprintf(cmd, "%s -noborder -game %s %s\n", cbase, engine_game, cArgs);

	system(cmd);
}

gboolean resize_list(GtkWidget *window, GdkEvent *event, GtkWidget *widget)
{
	gint width, height;
	iGameCnt = 1;
	gtk_window_get_size(GTK_WINDOW(window), &width, &height);
	gtk_widget_set_size_request(widget, 440, height - (118+41));
}

void launcher_settings_window()
{
/*	GtkWidget *prefwindow;
	GtkWidget *hbox1, *hbox2;
	GtkWidget *vbox1, *vbox2;

	vbox1 = gtk_vbox_new(TRUE, 1);
	vbox2 = gtk_vbox_new(TRUE, 1);
	hbox1 = gtk_hbox_new(TRUE, 1);
	hbox2 = gtk_hbox_new(TRUE, 1);

	prefwindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
	gtk_window_set_title (prefwindow, "NGUNIX - Engine Settings");
	gtk_container_set_border_width(GTK_CONTAINER(prefwindow), 10);

	gtk_container_add(GTK_CONTAINER(prefwindow), vbox1);
	gtk_container_add(GTK_CONTAINER(vbox1), hbox1);
	gtk_container_add(GTK_CONTAINER(vbox1), hbox2);

	GtkLabel *label1 = gtk_label_new("Video Width");
	GtkLabel *label2 = gtk_label_new("Video Height");
	GtkLabel *label3 = gtk_label_new("Video Memory");
	gtk_fixed_put(GTK_FIXED(ltable1), label1, 0, 0);
	gtk_fixed_put(GTK_FIXED(ltable1), label2, 0, 20);
	gtk_fixed_put(GTK_FIXED(ltable1), label3, 0, 40);

	GtkWidget *entry1 = gtk_entry_new();
	GtkWidget *entry2 = gtk_entry_new();
	GtkWidget *entry3 = gtk_entry_new();

	char vid_width[4], vid_height[4], vid_mem[3];
	sprintf(vid_width, "%d", engine_vid_width);
	sprintf(vid_height, "%d", engine_vid_height);
	sprintf(vid_mem, "%d", engine_memory);
	GtkEntryBuffer *buf1 = gtk_entry_buffer_new(vid_width, 4);
	GtkEntryBuffer *buf2 = gtk_entry_buffer_new(vid_height, 4);
	GtkEntryBuffer *buf3 = gtk_entry_buffer_new(vid_mem, 3);
	gtk_fixed_put(GTK_FIXED(ltable1), entry1, 90, 0);
	gtk_fixed_put(GTK_FIXED(ltable1), entry2, 90, 20);
	gtk_fixed_put(GTK_FIXED(ltable1), entry3, 90, 40);
	gtk_entry_set_buffer(entry1, buf1);
	gtk_entry_set_buffer(entry2, buf2);
	gtk_entry_set_buffer(entry3, buf3);
	
	GtkWidget *check1 = gtk_check_button_new_with_label("Window Borders");
	GtkWidget *check2 = gtk_check_button_new_with_label("Hide Unknown Mods");
	gtk_fixed_put(GTK_FIXED(ltable1), check1, 0, 60);
	gtk_fixed_put(GTK_FIXED(ltable1), check2, 0, 80);
  	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check1), engine_vid_border ? TRUE : FALSE);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check2), engine_hidden ? TRUE : FALSE);
	gtk_widget_show_all(prefwindow);
  
  	g_signal_connect(prefwindow, "destroy", G_CALLBACK(gtk_widget_hide), NULL);*/
}

int main(int argc, char *argv[]) 
{
	GtkWidget *window;
	GtkWidget *ltable1;

	GtkWidget *btnplay;
  	GtkWidget *btnsetting;
  	GtkWidget *btnquit;
	GtkWidget *listwindow;

	GdkBitmap *splash_mask;
	GdkPixmap *splash_image;
	GtkWidget *x_splash_image;
	GdkPixbuf *icon_image;

	GtkWidget *listgames;
	GtkTreeSelection *selection;

	if(argv[1])
	{
		chdir(argv[1]);
		printf("[LAUNCHER] Using Directory %s\n", argv[1]);
	}

	sprintf(engine_game, "data");

	gtk_init(&argc, &argv);
	launcher_settings_load();
	
	GdkGeometry hints;
    	hints.min_width = 444;
    	hints.max_width = 444;
    	hints.min_height = 225;
    	hints.max_height = 1080;

	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
  	gtk_window_set_title(GTK_WINDOW(window), "NGUNIX Launcher");
  	gtk_window_set_position(GTK_WINDOW(window), GTK_WIN_POS_CENTER);
	gtk_container_set_border_width(GTK_CONTAINER(window), 2);
	gtk_window_set_geometry_hints(GTK_WINDOW(window), window, &hints, (GdkWindowHints)(GDK_HINT_MIN_SIZE | GDK_HINT_MAX_SIZE));
	gtk_widget_realize(window);

	icon_image = gdk_pixbuf_new_from_xpm_data((const char**)icon_xpm);
	gtk_window_set_default_icon (icon_image);

	ltable1 = gtk_fixed_new();
	gtk_container_add(GTK_CONTAINER(window), ltable1);


	splash_image = gdk_pixmap_create_from_xpm_d(window->window, &splash_mask, NULL, (gchar **)splash_xpm );

	if(!access("./splash.xpm", R_OK))
		x_splash_image = gtk_image_new_from_file("./splash.xpm");
	else
		x_splash_image = gtk_image_new_from_pixmap(splash_image, splash_mask);

	gtk_fixed_put(GTK_FIXED(ltable1), x_splash_image, 0, 0);

	btnplay = gtk_button_new_from_stock(GTK_STOCK_MEDIA_PLAY);
  	btnsetting = gtk_button_new_from_stock(GTK_STOCK_PROPERTIES);
  	btnquit = gtk_button_new_from_stock(GTK_STOCK_QUIT);

	gtk_fixed_put(GTK_FIXED(ltable1), btnplay, 0, 118);
	gtk_widget_set_size_request(btnplay, 146, 40);
	gtk_fixed_put(GTK_FIXED(ltable1), btnsetting, 148, 118);
	gtk_widget_set_size_request(btnsetting, 144, 40);
	gtk_fixed_put(GTK_FIXED(ltable1), btnquit, 148+146, 118);
	gtk_widget_set_size_request(btnquit, 144, 40);

	listwindow = gtk_scrolled_window_new (NULL, NULL);
	gtk_fixed_put(GTK_FIXED(ltable1), listwindow, 0, 118+41);

	listgames = gtk_tree_view_new();
	gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW (listwindow), listgames);
	gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(listwindow), GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
	gtk_widget_set_size_request(listwindow, 440, 300);

	launcher_init_list(listgames);
  	selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(listgames));

  	gtk_widget_show_all(window);
  
  	g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);  
	g_signal_connect(selection, "changed", G_CALLBACK(launcher_list_changed), listgames);
	gtk_signal_connect (GTK_OBJECT (btnplay), "clicked", GTK_SIGNAL_FUNC (launcher_start),NULL);
	gtk_signal_connect (GTK_OBJECT (btnsetting), "clicked", GTK_SIGNAL_FUNC (launcher_settings_window),NULL);
	gtk_signal_connect (GTK_OBJECT (btnquit), "clicked", GTK_SIGNAL_FUNC (gtk_main_quit),NULL);
	g_signal_connect(G_OBJECT(window), "configure-event", G_CALLBACK(resize_list), (gpointer)listwindow);

	printf("[LAUNCHER] Scanning directories....\n");
	launcher_cachefolders(listgames);
	printf(".......... %d folder(s) found\n", iGameCnt);

  	gtk_main();

  	return 0;
}