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

#include "RenegadeMapSelector.h"
#include "RenegadeConfig.h"

#ifdef _WIN32
#include <io.h>
#include <fcntl.h>
#include "resource.h"
#else
#include "gtk/gtk.h"
#endif

bool debug = false;
string program;
RenegadeConfig* config;

#ifndef _WIN32
inline string fix(const string& ansi) { return ansi; }
inline void munge(void) { debug = true; }

void message(const string& text, const string& title, GtkMessageType type);
#else
inline string fix(const wstring& wide)
{
	char* buffer = new char[wide.length() + 1];

	WideCharToMultiByte(CP_ACP, 0, wide.c_str(), -1, buffer, wide.length() + 1,
		NULL, NULL);

	string ansi = buffer;
	delete [] buffer;

	return ansi;
}

inline void munge(void)
{
	if (debug) return;

	AllocConsole();
	SetConsoleTitle("Renegade Map Selector");

	int hin = _open_osfhandle(long(GetStdHandle(STD_INPUT_HANDLE)), _O_TEXT);
	int hout = _open_osfhandle(long(GetStdHandle(STD_OUTPUT_HANDLE)), _O_TEXT);
	int herr = _open_osfhandle(long(GetStdHandle(STD_ERROR_HANDLE)), _O_TEXT);

	FILE* fin = _fdopen(hin, "r");
	FILE* fout = _fdopen(hout, "w");
	FILE* ferr = _fdopen(herr, "w");

	*stdin = *fin;
	*stdout = *fout;
	*stderr = *ferr;

	setvbuf(stdin, NULL, _IONBF, 0);
	setvbuf(stdout, NULL, _IONBF, 0);
	setvbuf(stderr, NULL, _IONBF, 0);

	cin.sync_with_stdio();
	cout.sync_with_stdio();
	cerr.sync_with_stdio();

	debug = true;
}
#endif

#ifdef _WIN32
int CALLBACK selector(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR
	lpCmdLine, int nShowCmd)
{
	int argc;
	unsigned short** argv = CommandLineToArgvW(GetCommandLineW(), &argc);
#else
void selector(void);

int main(int argc, char* argv[])
{
	gtk_init(&argc, &argv);
#endif

	string error;
	string file = "svrcfg_cnc.ini";

	program = fix(argv[0]);

	for (int index = 1; index < argc; index++)
	{
		string arg = fix(argv[index]);

		if (arg == "-D")
		{
			munge();
		}
		else if (arg == "-file")
		{
			if (++index < argc)
			{
				file = fix(argv[index]);
			}
			else
			{
				error = "The argument -file must be followed by a filename.";

#ifdef _WIN32
				MessageBox(NULL, error.c_str(), "Bad Arguments", MB_ICONERROR);
#else
				message(error, "Bad Arguments", GTK_MESSAGE_ERROR);
#endif
				return 1;
			}
		}
	}

#ifdef _WIN32
	GlobalFree(argv);
#endif

	if (debug) cerr << "file = " << file << "\n";

	config = new RenegadeConfig(file);
	if (!config->load())
	{
		error = "Could not open " + file + ".";

#ifdef _WIN32
		MessageBox(NULL, error.c_str(), "Bad File", MB_ICONERROR);
#else
		message(error, "Bad File", GTK_MESSAGE_ERROR);
#endif
		return 1;
	}

#ifdef _WIN32
	DialogBox(hInstance, MAKEINTRESOURCE(IDD_MAP_SELECTOR), NULL, selector);
#else
	selector();
#endif

	delete config;

#ifdef _WIN32
	if (debug)
	{
		cout << "Press enter key to exit . . .";
		cin.get();
	}
#endif

	return 0;
}

#ifdef _WIN32
int CALLBACK selector(HWND hwndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
	case WM_INITDIALOG:
		{
			RECT rc, rcDlg, rcDesktop;

			GetWindowRect(GetDesktopWindow(), &rcDesktop);
			GetWindowRect(hwndDlg, &rcDlg);
			CopyRect(&rc, &rcDesktop);

			OffsetRect(&rcDlg, -rcDlg.left, -rcDlg.top);
			OffsetRect(&rc, -rc.left, -rc.top);
			OffsetRect(&rc, -rcDlg.right, -rcDlg.bottom);

			SetWindowPos(hwndDlg, HWND_TOP, rcDesktop.left + (rc.right / 2),
				rcDesktop.top + (rc.bottom / 2), 0, 0, SWP_NOSIZE);
		}
		{
			char* directory = new char[MAX_PATH + 1];
			GetCurrentDirectory(MAX_PATH + 1, directory);
			if (debug) cerr << "directory = " << directory << "\n";

			char* data = new char[MAX_PATH + 1];
			sprintf(data, "%s\\data\\*.mix", directory);
			delete [] directory;
			if (debug) cerr << "data = " << data << "\n";

			DlgDirList(hwndDlg, data, IDC_AVAILABLE, 0, DDL_ARCHIVE);
			SetCurrentDirectory("..");

			delete [] data;
		}
		{
			vector<string> maps = config->getMaps();

			for (unsigned index = 0; index < maps.size(); index++)
			{
				SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_ADDSTRING, 0,
					long(maps[index].c_str()));
			}
		}
		break;
	case WM_COMMAND:
		switch (LOWORD(wParam))
		{
		case IDOK:
			if (GetListBoxInfo(GetDlgItem(hwndDlg, IDC_SELECTED)) == 0)
			{
				MessageBox(hwndDlg, "You need at least one map.", "No Maps",
					MB_ICONEXCLAMATION);

				return false;
			}
			else
			{
				vector<string> maps;

				for (unsigned index = 0; index < GetListBoxInfo(GetDlgItem(
					hwndDlg, IDC_SELECTED)); index++)
				{
					char* name = new char[SendMessage(GetDlgItem(hwndDlg,
						IDC_SELECTED), LB_GETTEXTLEN, index, 0) + 1];

					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_GETTEXT,
						index, long(name));
					maps.push_back(name);

					delete [] name;
				}

				config->setMaps(maps);
			}
			config->save();
		case IDCANCEL:
			EndDialog(hwndDlg, wParam);
			return true;
		case IDC_ADD_MAP:
			{
				unsigned count = SendMessage(GetDlgItem(hwndDlg,
					IDC_AVAILABLE), LB_GETSELCOUNT, 0, 0);
				unsigned* additions = new unsigned[count];

				SendMessage(GetDlgItem(hwndDlg, IDC_AVAILABLE), LB_GETSELITEMS,
					count, long(additions));

				if (debug) cerr << "additions = {\n";
				for (unsigned index = 0; index < count; index++)
				{
					if (debug) cerr << "   [" << index << "] = " <<
						additions[index] << "\n";

					char* name = new char[SendMessage(GetDlgItem(hwndDlg,
						IDC_AVAILABLE), LB_GETTEXTLEN, additions[index], 0) + 1
						];

					SendMessage(GetDlgItem(hwndDlg, IDC_AVAILABLE), LB_GETTEXT,
						additions[index], long(name));
					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
						LB_ADDSTRING, 0, long(name));

					delete [] name;
				}
				if (debug) cerr << "}\n";

				delete [] additions;

				SendMessage(GetDlgItem(hwndDlg, IDC_AVAILABLE), LB_SETSEL,
					false, -1);
				EnableWindow(GetDlgItem(hwndDlg, IDC_ADD_MAP), false);
			}
			break;
		case IDC_REMOVE_MAP:
			{
				unsigned count = SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
					LB_GETSELCOUNT, 0, 0);
				unsigned* removals = new unsigned[count];

				SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_GETSELITEMS,
					count, long(removals));

				if (debug) cerr << "removals = {\n";
				for (unsigned index = count; index > 0; index--)
				{
					if (debug) cerr << "   [" << index - 1 << "] = " <<
						removals[index - 1] << "\n";

					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
						LB_DELETESTRING, removals[index - 1], 0);
				}
				if (debug) cerr << "}\n";

				delete [] removals;

				EnableWindow(GetDlgItem(hwndDlg, IDC_REMOVE_MAP), false);
				EnableWindow(GetDlgItem(hwndDlg, IDC_UP_MAP), false);
				EnableWindow(GetDlgItem(hwndDlg, IDC_DOWN_MAP), false);
			}
			break;
		case IDC_UP_MAP:
			{
				unsigned count = SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
					LB_GETSELCOUNT, 0, 0);
				unsigned* ups = new unsigned[count];

				SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_GETSELITEMS,
					count, long(ups));

				unsigned insert = ups[0] - 1;

				if (debug) cerr << "ups = {\n";
				for (unsigned index = 0; index < count; index++)
				{
					if (debug) cerr << "   [" << index << "] = " << ups[index]
						<< "\n";

					char* up = new char[SendMessage(GetDlgItem(hwndDlg,
						IDC_SELECTED), LB_GETTEXTLEN, ups[index], 0) + 1];

					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_GETTEXT,
						ups[index], long(up));
					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
						LB_DELETESTRING, ups[index], 0);
					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
						LB_INSERTSTRING, insert, long(up));
					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_SETSEL,
						true, insert++);
				}
				if (debug) cerr << "}\n";

				delete [] ups;

				if (SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
					LB_GETSEL, 0, 0) == 0)
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_UP_MAP), true);
				}
				else
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_UP_MAP), false);
				}

				if (SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
					LB_GETSEL, SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED
					), LB_GETCOUNT, 0, 0) - 1, 0) == 0)
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_DOWN_MAP), true);
				}
			}
			break;
		case IDC_DOWN_MAP:
			{
				unsigned count = SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
					LB_GETSELCOUNT, 0, 0);
				unsigned* downs = new unsigned[count];

				SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_GETSELITEMS,
					count, long(downs));

				unsigned insert = downs[count - 1] + 1;

				if (debug) cerr << "downs = {\n";
				for (unsigned index = count; index > 0; index--)
				{
					if (debug) cerr << "   [" << index << "] = " << downs[index
						- 1] << "\n";

					char* down = new char[SendMessage(GetDlgItem(hwndDlg,
						IDC_SELECTED), LB_GETTEXTLEN, downs[index - 1], 0) +
						1];

					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_GETTEXT,
						downs[index - 1], long(down));
					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
						LB_DELETESTRING, downs[index - 1], 0);
					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
						LB_INSERTSTRING, insert, long(down));
					SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED), LB_SETSEL,
						true, insert--);
				}
				if (debug) cerr << "}\n";

				delete [] downs;

				if (SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
					LB_GETSEL, 0, 0) == 0)
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_UP_MAP), true);
				}

				if (SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
					LB_GETSEL, SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED
					), LB_GETCOUNT, 0, 0) - 1, 0) == 0)
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_DOWN_MAP), true);
				}
				else
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_DOWN_MAP), false);
				}
			}
			break;
		case IDC_AVAILABLE:
			switch (HIWORD(wParam))
			{
			case LBN_SELCHANGE:
				if (SendMessage(GetDlgItem(hwndDlg, IDC_AVAILABLE),
					LB_GETSELCOUNT, 0, 0) > 0)
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_ADD_MAP), true);
				}
				else
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_ADD_MAP), false);
				}
				break;
			}
			break;
		case IDC_SELECTED:
			switch (HIWORD(wParam))
			{
			case LBN_SELCHANGE:
				if (SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
					LB_GETSELCOUNT, 0, 0) > 0)
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_REMOVE_MAP), true);
					
					if (SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
						LB_GETSEL, 0, 0) == 0)
					{
						EnableWindow(GetDlgItem(hwndDlg, IDC_UP_MAP), true);
					}
					else
					{
						EnableWindow(GetDlgItem(hwndDlg, IDC_UP_MAP), false);
					}

					if (SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED),
						LB_GETSEL, SendMessage(GetDlgItem(hwndDlg, IDC_SELECTED
						), LB_GETCOUNT, 0, 0) - 1, 0) == 0)
					{
						EnableWindow(GetDlgItem(hwndDlg, IDC_DOWN_MAP), true);
					}
					else
					{
						EnableWindow(GetDlgItem(hwndDlg, IDC_DOWN_MAP), false);
					}
				}
				else
				{
					EnableWindow(GetDlgItem(hwndDlg, IDC_REMOVE_MAP), false);
					EnableWindow(GetDlgItem(hwndDlg, IDC_UP_MAP), false);
					EnableWindow(GetDlgItem(hwndDlg, IDC_DOWN_MAP), false);
				}
				break;
			}
			break;
		}
		break;
	}

	return false;
}
#else
static void destruct(GtkWidget* widget, gpointer data)
{
	gtk_main_quit();
}

static void done(GtkWidget* widget, gpointer data)
{
	if (true)
	{
		message("You need at least one map.", "No Maps",
			GTK_MESSAGE_WARNING);
	}
	else
	{
		//

		config->save();

		gtk_main_quit();
	}
}

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

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

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

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

void selector(void)
{
	GtkWidget* 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),
		NULL);

	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* 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);

	GtkWidget* add = gtk_button_new_with_mnemonic("_Add");

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

	GtkWidget* remove = gtk_button_new_with_mnemonic("_Remove");

	g_signal_connect(G_OBJECT(remove), "clicked", G_CALLBACK(mapRemove), NULL);
	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);

	GtkWidget* up = gtk_button_new_with_mnemonic("_Up");

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

	GtkWidget* down = gtk_button_new_with_mnemonic("_Down");

	g_signal_connect(G_OBJECT(down), "clicked", G_CALLBACK(mapDown), NULL);
	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* 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), NULL);

	GtkWidget* cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);

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

	// pack
	gtk_container_add(GTK_CONTAINER(vertical), horizontal);
	gtk_container_add(GTK_CONTAINER(horizontal), left);
	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(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(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(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 message(const string& text, const string& title, GtkMessageType type)
{
	GtkWidget* box = gtk_message_dialog_new(NULL, GTK_DIALOG_MODAL, type,
		GTK_BUTTONS_OK, text.c_str());

	gtk_window_set_title(GTK_WINDOW(box), title.c_str());

	gtk_dialog_run(GTK_DIALOG(box));
	gtk_widget_destroy(box);
}
#endif