// Renegade Map Selector
//
// Douglas Thrift
//
// MapSelector.cpp

#include "MapSelector.h"

#ifndef _WIN32

MapSelector::MapSelector()
{
	window = gtk_window_new(GTK_WINDOW_TOPLEVEL);

	gtk_window_set_title(GTK_WINDOW(window), "Renegade Map Selector");
	gtk_window_set_resizable(GTK_WINDOW(window), false);
	g_signal_connect(G_OBJECT(window), "delete_event", G_CALLBACK(destruct),
		this);

	GtkWidget* vertical = gtk_vbox_new(false, 0);
	GtkWidget* horizontal = gtk_hbox_new(false, 9);
	GtkWidget* left = gtk_frame_new("Available Maps");

	gtk_frame_set_label_align(GTK_FRAME(left), 0.5, 0.5);
	gtk_container_set_border_width(GTK_CONTAINER(left), 6);

	GtkWidget* leftScroll = gtk_scrolled_window_new(NULL, NULL);
	
	gtk_container_set_border_width(GTK_CONTAINER(leftScroll), 6);
	gtk_widget_set_size_request(leftScroll, 150, 200);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(leftScroll),
		GTK_SHADOW_IN);

	available = gtk_tree_view_new();

	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(available), false);
	setupAvailable();

	GtkWidget* center = gtk_vbox_new(true, 0);
	GtkWidget* top = gtk_vbutton_box_new();

	gtk_button_box_set_layout(GTK_BUTTON_BOX(top), GTK_BUTTONBOX_START);
	gtk_box_set_spacing(GTK_BOX(top), 9);
	gtk_container_set_border_width(GTK_CONTAINER(top), 6);

	add = gtk_button_new_with_mnemonic("_Add");

	g_signal_connect(G_OBJECT(add), "clicked", G_CALLBACK(mapAdd), this);
	gtk_widget_set_sensitive(add, false);

	remove = gtk_button_new_with_mnemonic("_Remove");

	g_signal_connect(G_OBJECT(remove), "clicked", G_CALLBACK(mapRemove), this);
	gtk_widget_set_sensitive(remove, false);

	GtkWidget* middle = gtk_vbutton_box_new();

	gtk_button_box_set_layout(GTK_BUTTON_BOX(middle), GTK_BUTTONBOX_END);
	gtk_box_set_spacing(GTK_BOX(middle), 9);
	gtk_container_set_border_width(GTK_CONTAINER(middle), 6);

	up = gtk_button_new_with_mnemonic("_Up");

	g_signal_connect(G_OBJECT(up), "clicked", G_CALLBACK(mapUp), this);
	gtk_widget_set_sensitive(up, false);

	down = gtk_button_new_with_mnemonic("_Down");

	g_signal_connect(G_OBJECT(down), "clicked", G_CALLBACK(mapDown), this);
	gtk_widget_set_sensitive(down, false);

	GtkWidget* right = gtk_frame_new("Selected Maps");

	gtk_frame_set_label_align(GTK_FRAME(right), 0.5, 0.5);
	gtk_container_set_border_width(GTK_CONTAINER(right), 6);

	GtkWidget* rightScroll = gtk_scrolled_window_new(NULL, NULL);

	gtk_container_set_border_width(GTK_CONTAINER(rightScroll), 6);
	gtk_widget_set_size_request(rightScroll, 150, 200);
	gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(rightScroll),
		GTK_SHADOW_IN);

	selected = gtk_tree_view_new();

	gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(selected), false);
	setupSelected();

	GtkWidget* separator = gtk_hseparator_new();
	GtkWidget* bottom = gtk_hbutton_box_new();

	gtk_button_box_set_layout(GTK_BUTTON_BOX(bottom), GTK_BUTTONBOX_END);
	gtk_box_set_spacing(GTK_BOX(bottom), 9);
	gtk_container_set_border_width(GTK_CONTAINER(bottom), 6);

	GtkWidget* ok = gtk_button_new_from_stock(GTK_STOCK_OK);

	g_signal_connect(G_OBJECT(ok), "clicked", G_CALLBACK(done), this);

	GtkWidget* cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);

	g_signal_connect(G_OBJECT(cancel), "clicked", G_CALLBACK(destruct), this);

	// pack
	gtk_container_add(GTK_CONTAINER(vertical), horizontal);
	gtk_container_add(GTK_CONTAINER(horizontal), left);
	gtk_container_add(GTK_CONTAINER(left), leftScroll);
	gtk_container_add(GTK_CONTAINER(leftScroll), available);
	gtk_container_add(GTK_CONTAINER(horizontal), center);
	gtk_container_add(GTK_CONTAINER(center), top);
	gtk_container_add(GTK_CONTAINER(top), add);
	gtk_container_add(GTK_CONTAINER(top), remove);
	gtk_container_add(GTK_CONTAINER(center), middle);
	gtk_container_add(GTK_CONTAINER(middle), up);
	gtk_container_add(GTK_CONTAINER(middle), down);
	gtk_container_add(GTK_CONTAINER(horizontal), right);
	gtk_container_add(GTK_CONTAINER(right), rightScroll);
	gtk_container_add(GTK_CONTAINER(rightScroll), selected);
	gtk_container_add(GTK_CONTAINER(vertical), separator);
	gtk_container_add(GTK_CONTAINER(bottom), ok);
	gtk_container_add(GTK_CONTAINER(bottom), cancel);
	gtk_container_add(GTK_CONTAINER(vertical), bottom);
	gtk_container_add(GTK_CONTAINER(window), vertical);

	// show
	gtk_widget_show(available);
	gtk_widget_show(leftScroll);
	gtk_widget_show(left);
	gtk_widget_show(add);
	gtk_widget_show(remove);
	gtk_widget_show(top);
	gtk_widget_show(up);
	gtk_widget_show(down);
	gtk_widget_show(middle);
	gtk_widget_show(center);
	gtk_widget_show(selected);
	gtk_widget_show(rightScroll);
	gtk_widget_show(right);
	gtk_widget_show(horizontal);
	gtk_widget_show(separator);
	gtk_widget_show(ok);
	gtk_widget_show(cancel);
	gtk_widget_show(bottom);
	gtk_widget_show(vertical);
	gtk_widget_show(window);

	gtk_main();
}

void MapSelector::setupAvailable()
{
	GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);

	char* directory = new char[MAXPATHLEN + 1];
	getcwd(directory, MAXPATHLEN + 1);
	if (debug) cerr << "directory = " << directory << "\n";

	char* data = new char[strlen(directory) + 6];
	sprintf(data, "%s/data", directory);
	delete [] directory;
	if (debug) cerr << "data = " << data << "\n";

	DIR* dir = opendir(data);
	delete [] data;

	GtkTreeIter itor;
	dirent* file;
	while ((file = readdir(dir)) != NULL)
	{
		string name = file->d_name;

		if (name.rfind(".mix") == name.length() - 4)
		{
			gtk_list_store_append(store, &itor);
			gtk_list_store_set(store, &itor, 0, name.c_str(), -1);
		}
	}

	closedir(dir);

	gtk_tree_view_set_model(GTK_TREE_VIEW(available), GTK_TREE_MODEL(store));

	GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
	GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(NULL,
		renderer, "text", 0, NULL);

	gtk_tree_view_append_column(GTK_TREE_VIEW(available), column);
}

void MapSelector::setupSelected()
{
	GtkListStore* store = gtk_list_store_new(1, G_TYPE_STRING);

	vector<string> maps = config->getMaps();

	GtkTreeIter itor;
	for (unsigned index = 0; index < maps.size(); index++)
	{
		gtk_list_store_append(store, &itor);
		gtk_list_store_set(store, &itor, 0, maps[index].c_str(), -1);
	}

	gtk_tree_view_set_model(GTK_TREE_VIEW(selected), GTK_TREE_MODEL(store));

	GtkCellRenderer* renderer = gtk_cell_renderer_text_new();
	GtkTreeViewColumn* column = gtk_tree_view_column_new_with_attributes(NULL,
		renderer, "text", 0, NULL);

	gtk_tree_view_append_column(GTK_TREE_VIEW(selected), column);
}

void destruct(GtkWidget* widget, MapSelector* data)
{
	gtk_main_quit();
}

void done(GtkWidget* widget, MapSelector* data)
{
	GtkTreeModel* store = gtk_tree_view_get_model(GTK_TREE_VIEW(data->selected)
		);
	
	GtkTreeIter itor;
	if (!gtk_tree_model_get_iter_first(store, &itor))
	{
		message(GTK_WINDOW(data->window), "You need at least one map.",
			"No Maps", GTK_MESSAGE_WARNING);
	}
	else
	{
		vector<string> maps;

		do
		{
			char* name;

			gtk_tree_model_get(store, &itor, 0, &name, -1);
			maps.push_back(name);

			g_free(name);
		}
		while (gtk_tree_model_iter_next(store, &itor));

		config->setMaps(maps);
		
		config->save();

		gtk_main_quit();
	}
}

void mapAdd(GtkWidget* widget, MapSelector* data)
{
	cout << "STUB: add\n\a" << flush;
}

void mapRemove(GtkWidget* widget, MapSelector* data)
{
	cout << "STUB: remove\n\a" << flush;
}

void mapUp(GtkWidget* widget, MapSelector* data)
{
	cout << "STUB: up\n\a" << flush;
}

void mapDown(GtkWidget* widget, MapSelector* data)
{
	cout << "STUB: down\n\a" << flush;
}

#endif