/*****************************************************************************
 * Copyright (c) 2014 Ted John
 * OpenRCT2, an open source clone of Roller Coaster Tycoon 2.
 *
 * This file is part of OpenRCT2.
 *
 * OpenRCT2 is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.

 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.

 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *****************************************************************************/

#include "addresses.h"
#include "config.h"
#include "interface/themes.h"
#include "interface/title_sequences.h"
#include "localisation/language.h"
#include "localisation/localisation.h"
#include "network/network.h"
#include "openrct2.h"
#include "util/util.h"

// Magic number for original game cfg file
static const int MagicNumber = 0x0003113A;

enum {
	CONFIG_VALUE_TYPE_BOOLEAN,
	CONFIG_VALUE_TYPE_UINT8,
	CONFIG_VALUE_TYPE_UINT16,
	CONFIG_VALUE_TYPE_UINT32,
	CONFIG_VALUE_TYPE_SINT8,
	CONFIG_VALUE_TYPE_SINT16,
	CONFIG_VALUE_TYPE_SINT32,
	CONFIG_VALUE_TYPE_FLOAT,
	CONFIG_VALUE_TYPE_DOUBLE,
	CONFIG_VALUE_TYPE_STRING
};

size_t _configValueTypeSize[] = {
	sizeof(bool),
	sizeof(uint8),
	sizeof(uint16),
	sizeof(uint32),
	sizeof(sint8),
	sizeof(sint16),
	sizeof(sint32),
	sizeof(float),
	sizeof(double),
	sizeof(utf8string)
};

typedef union {
	sint32 value_sint32;

	bool value_boolean;
	sint8 value_sint8;
	sint16 value_sint16;
	uint8 value_uint8;
	uint16 value_uint16;
	uint32 value_uint32;
	float value_float;
	double value_double;
	utf8string value_string;
} value_union;

typedef struct {
	const_utf8string key;
	value_union value;
} config_enum_definition;

#define END_OF_ENUM { NULL, 0 }

typedef struct {
	size_t offset;
	const_utf8string property_name;
	uint8 type;
	value_union default_value;
	config_enum_definition *enum_definitions;
} config_property_definition;

typedef struct {
	void *base_address;
	const_utf8string section_name;
	config_property_definition *property_definitions;
	int property_definitions_count;
} config_section_definition;

#pragma region Enum definitions

config_enum_definition _screenShotFormatEnum[] = {
	{ "BMP", SCREENSHOT_FORMAT_BMP },
	{ "PNG", SCREENSHOT_FORMAT_PNG },
	END_OF_ENUM
};

config_enum_definition _measurementFormatEnum[] = {
	{ "IMPERIAL", MEASUREMENT_FORMAT_IMPERIAL },
	{ "METRIC", MEASUREMENT_FORMAT_METRIC },
	END_OF_ENUM
};

config_enum_definition _temperatureFormatEnum[] = {
	{ "CELSIUS", TEMPERATURE_FORMAT_C },
	{ "FAHRENHEIT", TEMPERATURE_FORMAT_F },
	END_OF_ENUM
};

config_enum_definition _currencyEnum[] = {
	{ "GBP", CURRENCY_POUNDS },
	{ "USD", CURRENCY_DOLLARS },
	{ "FRF", CURRENCY_FRANC },
	{ "DEM", CURRENCY_DEUTSCHMARK },
	{ "JPY", CURRENCY_YEN },
	{ "ESP", CURRENCY_PESETA },
	{ "ITL", CURRENCY_LIRA },
	{ "NLG", CURRENCY_GUILDERS },
	{ "SEK", CURRENCY_KRONA },
	{ "EUR", CURRENCY_EUROS },
	{ "KRW", CURRENCY_WON },
	{ "RUB", CURRENCY_ROUBLE },
	END_OF_ENUM
};

config_enum_definition _languageEnum[] = {
	{ "en-GB", 	LANGUAGE_ENGLISH_UK },
	{ "en-US", 	LANGUAGE_ENGLISH_US },
	{ "de-DE", 	LANGUAGE_GERMAN },
	{ "nl-NL", 	LANGUAGE_DUTCH },
	{ "fr-FR", 	LANGUAGE_FRENCH },
	{ "hu-HU", 	LANGUAGE_HUNGARIAN },
	{ "pl-PL", 	LANGUAGE_POLISH },
	{ "es-ES", 	LANGUAGE_SPANISH },
	{ "sv-SE", 	LANGUAGE_SWEDISH },
	{ "it-IT", 	LANGUAGE_ITALIAN },
	{ "pt-BR", 	LANGUAGE_PORTUGUESE_BR },
	{ "zh-Hant",LANGUAGE_CHINESE_TRADITIONAL },
	{ "zh-Hans",LANGUAGE_CHINESE_SIMPLIFIED },
	{ "fi-FI", 	LANGUAGE_FINNISH },
	{ "ko", 	LANGUAGE_KOREAN },
	{ "ru-RU", 	LANGUAGE_RUSSIAN },
	{ "cz-CZ", 	LANGUAGE_CZECH },
	END_OF_ENUM
};

config_enum_definition _dateFormatEnum[] = {
	{ "DD/MM/YY", DATE_FORMAT_DMY },
	{ "MM/DD/YY", DATE_FORMAT_MDY },
	END_OF_ENUM
};

#pragma endregion

#pragma region Section / property definitions

config_property_definition _generalDefinitions[] = {
	{ offsetof(general_configuration, always_show_gridlines),			"always_show_gridlines",		CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, autosave_frequency),				"autosave",						CONFIG_VALUE_TYPE_UINT8,		AUTOSAVE_EVERY_5MINUTES,		NULL					},
	{ offsetof(general_configuration, confirmation_prompt),				"confirmation_prompt",			CONFIG_VALUE_TYPE_UINT8,		0,								NULL					},
	{ offsetof(general_configuration, construction_marker_colour),		"construction_marker_colour",	CONFIG_VALUE_TYPE_UINT8,		false,							NULL					},
	{ offsetof(general_configuration, currency_format),					"currency_format",				CONFIG_VALUE_TYPE_UINT8,		CURRENCY_POUNDS,				_currencyEnum			},
	{ offsetof(general_configuration, edge_scrolling),					"edge_scrolling",				CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(general_configuration, fullscreen_mode),					"fullscreen_mode",				CONFIG_VALUE_TYPE_UINT8,		0,								NULL					},
	{ offsetof(general_configuration, fullscreen_height),				"fullscreen_height",			CONFIG_VALUE_TYPE_SINT32,		-1,								NULL					},
	{ offsetof(general_configuration, fullscreen_width),				"fullscreen_width",				CONFIG_VALUE_TYPE_SINT32,		-1,								NULL					},
	{ offsetof(general_configuration, game_path),						"game_path",					CONFIG_VALUE_TYPE_STRING,		{ .value_string = NULL },		NULL					},
	{ offsetof(general_configuration, landscape_smoothing),				"landscape_smoothing",			CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(general_configuration, language),						"language",						CONFIG_VALUE_TYPE_UINT16,		LANGUAGE_ENGLISH_UK,			_languageEnum			},
	{ offsetof(general_configuration, measurement_format),				"measurement_format",			CONFIG_VALUE_TYPE_UINT8,		MEASUREMENT_FORMAT_IMPERIAL,	_measurementFormatEnum	},
	{ offsetof(general_configuration, play_intro),						"play_intro",					CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, save_plugin_data),				"save_plugin_data",				CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, debugging_tools),					"debugging_tools",				CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, screenshot_format),				"screenshot_format",			CONFIG_VALUE_TYPE_UINT8,		SCREENSHOT_FORMAT_PNG,			_screenShotFormatEnum	},
	{ offsetof(general_configuration, show_height_as_units),			"show_height_as_units",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, temperature_format),				"temperature_format",			CONFIG_VALUE_TYPE_UINT8,		TEMPERATURE_FORMAT_C,			_temperatureFormatEnum	},
	{ offsetof(general_configuration, window_height),					"window_height",				CONFIG_VALUE_TYPE_SINT32,		-1,								NULL					},
	{ offsetof(general_configuration, window_snap_proximity),			"window_snap_proximity",		CONFIG_VALUE_TYPE_UINT8,		5,								NULL					},
	{ offsetof(general_configuration, window_width),					"window_width",					CONFIG_VALUE_TYPE_SINT32,		-1,								NULL					},
	{ offsetof(general_configuration, hardware_display),				"hardware_display",				CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, uncap_fps),						"uncap_fps",					CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, test_unfinished_tracks),			"test_unfinished_tracks",		CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, no_test_crashes),					"no_test_crashes",				CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, date_format),						"date_format",					CONFIG_VALUE_TYPE_UINT8,		DATE_FORMAT_DMY,				_dateFormatEnum			},
	{ offsetof(general_configuration, auto_staff_placement),			"auto_staff",					CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, handymen_mow_default),			"handymen_mow_default",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, last_run_version),				"last_run_version",				CONFIG_VALUE_TYPE_STRING,		{ .value_string = NULL },		NULL					},
	{ offsetof(general_configuration, invert_viewport_drag),			"invert_viewport_drag",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, load_save_sort),					"load_save_sort",				CONFIG_VALUE_TYPE_UINT8,		SORT_NAME_ASCENDING,			NULL					},
	{ offsetof(general_configuration, minimize_fullscreen_focus_loss),	"minimize_fullscreen_focus_loss",CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(general_configuration, day_night_cycle),					"day_night_cycle",				CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, upper_case_banners),				"upper_case_banners",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(general_configuration, allow_loading_with_incorrect_checksum),"allow_loading_with_incorrect_checksum",	CONFIG_VALUE_TYPE_BOOLEAN,		false,			NULL					},
	{ offsetof(general_configuration, steam_overlay_pause),				"steam_overlay_pause",			CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(general_configuration, window_scale),					"window_scale",					CONFIG_VALUE_TYPE_FLOAT,		{ .value_float = 1.0f },							NULL					},
};

config_property_definition _interfaceDefinitions[] = {
	{ offsetof(interface_configuration, toolbar_show_finances),			"toolbar_show_finances",		CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(interface_configuration, toolbar_show_research),			"toolbar_show_research",		CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(interface_configuration, toolbar_show_cheats),			"toolbar_show_cheats",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(interface_configuration, toolbar_show_news),				"toolbar_show_news",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(interface_configuration, select_by_track_type),			"select_by_track_type",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(interface_configuration, console_small_font),			"console_small_font",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(interface_configuration, current_theme_preset),			"current_theme",				CONFIG_VALUE_TYPE_STRING,		{ .value_string = "*RCT2" },	NULL					},
	{ offsetof(interface_configuration, current_title_sequence_preset),	"current_title_sequence",		CONFIG_VALUE_TYPE_STRING,		{ .value_string = "*OPENRCT2" },NULL					},
	{ offsetof(interface_configuration, object_selection_filter_flags),	"object_selection_filter_flags",CONFIG_VALUE_TYPE_UINT32,		0x7EF,							NULL					},
};

config_property_definition _soundDefinitions[] = {
	{ offsetof(sound_configuration, title_music),						"title_music",					CONFIG_VALUE_TYPE_UINT8,		2,								NULL					},
	{ offsetof(sound_configuration, sound),								"sound",						CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(sound_configuration, ride_music),						"ride_music",					CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(sound_configuration, audio_focus),						"audio_focus",					CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(sound_configuration, master_volume),						"master_volume",				CONFIG_VALUE_TYPE_UINT8,		100,							NULL					},
	{ offsetof(sound_configuration, music_volume),						"music_volume",					CONFIG_VALUE_TYPE_UINT8,		100,							NULL					},
	{ offsetof(sound_configuration, device),							"audio_device",					CONFIG_VALUE_TYPE_STRING,		{ .value_string = NULL },		NULL					},
};

config_property_definition _cheatDefinitions[] = {
	{ offsetof(cheat_configuration, fast_lift_hill),					"fast_lift_hill",				CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(cheat_configuration, disable_brakes_failure),			"disable_brakes_failure",		CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(cheat_configuration, disable_all_breakdowns),			"disable_all_breakdowns",		CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(cheat_configuration, unlock_all_prices),					"unlock_all_prices",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(cheat_configuration, build_in_pause_mode),				"build_in_pause_mode",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(cheat_configuration, ignore_ride_intensity),				"ignore_ride_intensity",		CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(cheat_configuration, disable_vandalism),					"disable_vandalism",			CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
};

config_property_definition _twitchDefinitions[] = {
	{ offsetof(twitch_configuration, channel),							"channel",						CONFIG_VALUE_TYPE_STRING,		{ .value_string = NULL },		NULL					},
	{ offsetof(twitch_configuration, enable_follower_peep_names),		"follower_peep_names",			CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(twitch_configuration, enable_follower_peep_tracking),	"follower_peep_tracking",		CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(twitch_configuration, enable_chat_peep_names),			"chat_peep_names",				CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(twitch_configuration, enable_chat_peep_tracking),		"chat_peep_tracking",			CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(twitch_configuration, enable_news),						"news",							CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					}
};

config_property_definition _networkDefinitions[] = {
	{ offsetof(network_configuration, player_name),						"player_name",					CONFIG_VALUE_TYPE_STRING,		{.value_string = "Player" },	NULL					},
	{ offsetof(network_configuration, default_port),					"default_port",					CONFIG_VALUE_TYPE_UINT32,		NETWORK_DEFAULT_PORT,			NULL					},
	{ offsetof(network_configuration, stay_connected),					"stay_connected",				CONFIG_VALUE_TYPE_BOOLEAN,		true,							NULL					},
	{ offsetof(network_configuration, advertise),						"advertise",					CONFIG_VALUE_TYPE_BOOLEAN,		false,							NULL					},
	{ offsetof(network_configuration, maxplayers),						"maxplayers",					CONFIG_VALUE_TYPE_UINT8,		16,								NULL					},
	{ offsetof(network_configuration, server_name),						"server_name",					CONFIG_VALUE_TYPE_STRING,		{.value_string = "Server" },	NULL					},
	{ offsetof(network_configuration, server_description),				"server_description",			CONFIG_VALUE_TYPE_STRING,		{.value_string = NULL },		NULL					},
	{ offsetof(network_configuration, master_server_url),				"master_server_url",			CONFIG_VALUE_TYPE_STRING,		{.value_string = NULL },		NULL					},
	{ offsetof(network_configuration, provider_name),					"provider_name",				CONFIG_VALUE_TYPE_STRING,		{.value_string = NULL },		NULL					},
	{ offsetof(network_configuration, provider_email),					"provider_email",				CONFIG_VALUE_TYPE_STRING,		{.value_string = NULL },		NULL					},
	{ offsetof(network_configuration, provider_website),				"provider_website",				CONFIG_VALUE_TYPE_STRING,		{.value_string = NULL },		NULL					}
};

config_section_definition _sectionDefinitions[] = {
	{ &gConfigGeneral, "general", _generalDefinitions, countof(_generalDefinitions) },
	{ &gConfigInterface, "interface", _interfaceDefinitions, countof(_interfaceDefinitions) },
	{ &gConfigSound, "sound", _soundDefinitions, countof(_soundDefinitions) },
	{ &gConfigCheat, "cheat", _cheatDefinitions, countof(_cheatDefinitions) },
	{ &gConfigTwitch, "twitch", _twitchDefinitions, countof(_twitchDefinitions) },
	{ &gConfigNetwork, "network", _networkDefinitions, countof(_networkDefinitions) }
};

#pragma endregion

general_configuration gConfigGeneral;
interface_configuration gConfigInterface;
sound_configuration gConfigSound;
cheat_configuration gConfigCheat;
twitch_configuration gConfigTwitch;
network_configuration gConfigNetwork;
themes_configuration gConfigThemes;
title_sequences_configuration gConfigTitleSequences;

bool config_open(const utf8string path);
bool config_save(const utf8string path);
static void config_read_properties(config_section_definition **currentSection, const_utf8string line);
static void config_save_property_value(SDL_RWops *file, uint8 type, value_union *value);
static bool config_read_enum(void *dest, int destSize, const utf8 *key, int keySize, config_enum_definition *enumDefinitions);
static void config_write_enum(SDL_RWops *file, uint8 type, value_union *value, config_enum_definition *enumDefinitions);

static void utf8_skip_whitespace(utf8 **outch);
static void utf8_skip_non_whitespace(utf8 **outch);

void config_apply_to_old_addresses();

static int rwopsreadc(SDL_RWops *file)
{
	int c = 0;
	if (SDL_RWread(file, &c, 1, 1) != 1)
		c = EOF;
	return c;
}

static void rwopswritec(SDL_RWops *file, char c)
{
	SDL_RWwrite(file, &c, 1, 1);
}

static void rwopsprintf(SDL_RWops *file, const char *format, ...)
{
	va_list args;
	va_start(args, format);

	char buffer[64];
	vsprintf(buffer, format, args);

	SDL_RWwrite(file, buffer, strlen(buffer), 1);

	va_end(args);
}

void config_set_defaults()
{
	int i, j;

	for (i = 0; i < countof(_sectionDefinitions); i++) {
		config_section_definition *section = &_sectionDefinitions[i];
		for (j = 0; j < section->property_definitions_count; j++) {
			config_property_definition *property = &section->property_definitions[j];
			value_union *destValue = (value_union*)((size_t)section->base_address + (size_t)property->offset);

			// Special dynamic defaults
			if (strcmp(property->property_name, "language") == 0){
				destValue->value_uint16 = platform_get_locale_language();
				if (destValue->value_uint16 == LANGUAGE_UNDEFINED)
					memcpy(destValue, &property->default_value, _configValueTypeSize[property->type]);
			}
			else if (strcmp(property->property_name, "currency_format") == 0){
				destValue->value_uint8 = platform_get_locale_currency();
			}
			else if (strcmp(property->property_name, "measurement_format") == 0){
				destValue->value_uint8 = platform_get_locale_measurement_format();
			}
			else if (strcmp(property->property_name, "temperature_format") == 0){
				destValue->value_uint8 = platform_get_locale_temperature_format();
			}
			else {
				// Use static default
				if (property->type == CONFIG_VALUE_TYPE_STRING) {
					// Copy the string to new memory
					const utf8 *src = property->default_value.value_string;
					const utf8 **dst = (const utf8**)&(destValue->value_string);
					if (src != NULL) {
						*dst = _strdup(property->default_value.value_string);
					}
				} else {
					memcpy(destValue, &property->default_value, _configValueTypeSize[property->type]);
				}
			}
		}
	}
}

bool config_open_default()
{
	utf8 path[MAX_PATH];

	platform_get_user_directory(path, NULL);
	strcat(path, "config.ini");
	if (config_open(path)) {
		config_apply_to_old_addresses();
		return true;
	}

	return false;
}

bool config_save_default()
{
	utf8 path[MAX_PATH];

	platform_get_user_directory(path, NULL);
	strcat(path, "config.ini");
	if (config_save(path)) {
		config_apply_to_old_addresses();
		return true;
	}

	return false;
}

bool config_open(const utf8string path)
{
	SDL_RWops *file;
	utf8string lineBuffer;
	size_t lineBufferCapacity;
	size_t lineLength;
	int c;
	config_section_definition *currentSection;

	file = SDL_RWFromFile(path, "rb");
	if (file == NULL)
		return false;

	currentSection = NULL;
	lineBufferCapacity = 64;
	lineBuffer = malloc(lineBufferCapacity);
	lineLength = 0;

	// Skim UTF-8 byte order mark
	SDL_RWread(file, lineBuffer, 3, 1);
	if (!utf8_is_bom(lineBuffer))
		SDL_RWseek(file, 0, RW_SEEK_SET);

	while ((c = rwopsreadc(file)) != EOF) {
		if (c == '\n' || c == '\r') {
			lineBuffer[lineLength++] = 0;
			config_read_properties(&currentSection, (const_utf8string)lineBuffer);
			lineLength = 0;
		} else {
			lineBuffer[lineLength++] = c;
		}

		if (lineLength >= lineBufferCapacity) {
			lineBufferCapacity *= 2;
			lineBuffer = realloc(lineBuffer, lineBufferCapacity);
		}
	}

	if (lineLength > 0) {
		lineBuffer[lineLength++] = 0;
		config_read_properties(&currentSection, lineBuffer);
	}

	free(lineBuffer);
	SDL_RWclose(file);
	return true;
}

bool config_save(const utf8string path)
{
	SDL_RWops *file;
	int i, j;
	value_union *value;

	file = SDL_RWFromFile(path, "wb");
	if (file == NULL) {
		log_error("Unable to write to config file.");
		return false;
	}

	for (i = 0; i < countof(_sectionDefinitions); i++) {
		config_section_definition *section = &_sectionDefinitions[i];

		rwopswritec(file, '[');
		SDL_RWwrite(file, section->section_name, strlen(section->section_name), 1);
		rwopswritec(file, ']');
		rwopswritec(file, '\n');

		for (j = 0; j < section->property_definitions_count; j++) {
			config_property_definition *property = &section->property_definitions[j];

			SDL_RWwrite(file, property->property_name, strlen(property->property_name), 1);
			SDL_RWwrite(file, " = ", 3, 1);

			value = (value_union*)((size_t)section->base_address + (size_t)property->offset);
			if (property->enum_definitions != NULL)
				config_write_enum(file, property->type, value, property->enum_definitions);
			else
				config_save_property_value(file, property->type, value);
			rwopswritec(file, '\n');
		}
		rwopswritec(file, '\n');
	}

	SDL_RWclose(file);
	return true;
}

static void config_save_property_value(SDL_RWops *file, uint8 type, value_union *value)
{
	switch (type) {
	case CONFIG_VALUE_TYPE_BOOLEAN:
		if (value->value_boolean) SDL_RWwrite(file, "true", 4, 1);
		else SDL_RWwrite(file, "false", 5, 1);
		break;
	case CONFIG_VALUE_TYPE_UINT8:
		rwopsprintf(file, "%u", value->value_uint8);
		break;
	case CONFIG_VALUE_TYPE_UINT16:
		rwopsprintf(file, "%u", value->value_uint16);
		break;
	case CONFIG_VALUE_TYPE_UINT32:
		rwopsprintf(file, "%lu", value->value_uint32);
		break;
	case CONFIG_VALUE_TYPE_SINT8:
		rwopsprintf(file, "%d", value->value_sint8);
		break;
	case CONFIG_VALUE_TYPE_SINT16:
		rwopsprintf(file, "%d", value->value_sint16);
		break;
	case CONFIG_VALUE_TYPE_SINT32:
		rwopsprintf(file, "%ld", value->value_sint32);
		break;
	case CONFIG_VALUE_TYPE_FLOAT:
		rwopsprintf(file, "%.3f", value->value_float);
		break;
	case CONFIG_VALUE_TYPE_DOUBLE:
		rwopsprintf(file, "%.6f", value->value_double);
		break;
	case CONFIG_VALUE_TYPE_STRING:
		rwopswritec(file, '"');
		if (value->value_string != NULL)
			SDL_RWwrite(file, value->value_string, strlen(value->value_string), 1);
		rwopswritec(file, '"');
		break;
	}
}

bool config_get_section(const utf8string line, const utf8 **sectionName, int *sectionNameSize)
{
	utf8 *ch;
	int c;

	ch = line;
	utf8_skip_whitespace(&ch);
	if (*ch != '[') return false;
	*sectionName = ++ch;

	while ((c = utf8_get_next(ch, (const utf8**)&ch)) != 0) {
		if (c == '#') return false;
		if (c == '[') return false;
		if (c == ' ') break;
		if (c == ']') break;
	}

	*sectionNameSize = ch - *sectionName - 1;
	return true;
}

bool config_get_property_name_value(const utf8string line, utf8 **propertyName, int *propertyNameSize, utf8 **value, int *valueSize)
{
	utf8 *ch;
	int c, lastC;
	bool quotes;

	ch = line;
	utf8_skip_whitespace(&ch);

	if (*ch == 0) return false;
	*propertyName = ch;

	while ((c = utf8_get_next(ch, (const utf8**)&ch)) != 0) {
		if (isspace(c) || c == '=') {
			*propertyNameSize = ch - *propertyName - 1;
			break;
		} else if (c == '#') {
			return false;
		}
	}

	if (*ch == 0) return false;
	utf8_skip_whitespace(&ch);
	if (*ch != '=') return false;
	ch++;
	utf8_skip_whitespace(&ch);
	if (*ch == 0) return false;

	if (*ch == '"') {
		ch++;
		quotes = true;
	} else {
		quotes = false;
	}
	*value = ch;

	while ((c = utf8_get_next(ch, (const utf8**)&ch)) != 0) {
		if (isspace(c) || c == '#') {
			if (!quotes) break;
		}
		lastC = c;
	}
	*valueSize = ch - *value - 1;
	if (quotes) (*valueSize)--;
	return true;
}

config_section_definition *config_get_section_def(const utf8 *name, int size)
{
	int i;

	for (i = 0; i < countof(_sectionDefinitions); i++) {
		const_utf8string sectionName = _sectionDefinitions[i].section_name;
		const int sectionNameSize = strnlen(sectionName, size);
		if (sectionNameSize == size && sectionName[size] == 0 && _strnicmp(sectionName, name, size) == 0)
			return &_sectionDefinitions[i];
	}

	return NULL;
}

config_property_definition *config_get_property_def(config_section_definition *section, const utf8 *name, int size)
{
	int i;

	for (i = 0; i < section->property_definitions_count; i++) {
		const_utf8string propertyName = section->property_definitions[i].property_name;
		const int propertyNameSize = strnlen(propertyName, size);
		if (propertyNameSize == size && propertyName[size] == 0 && _strnicmp(propertyName, name, size) == 0)
		{
			return &section->property_definitions[i];
		}
	}

	return NULL;
}

void config_set_property(const config_section_definition *section, const config_property_definition *property, const utf8 *value, int valueSize)
{
	value_union *destValue = (value_union*)((size_t)section->base_address + (size_t)property->offset);

	if (property->enum_definitions != NULL)
		if (config_read_enum(destValue, _configValueTypeSize[property->type], value, valueSize, property->enum_definitions))
			return;

	switch (property->type) {
	case CONFIG_VALUE_TYPE_BOOLEAN:
		if (_strnicmp(value, "false", valueSize) == 0) destValue->value_boolean = false;
		else if (_strnicmp(value, "true", valueSize) == 0) destValue->value_boolean = true;
		else destValue->value_boolean = strtol(value, NULL, 0) != 0;
		break;
	case CONFIG_VALUE_TYPE_UINT8:
		destValue->value_uint8 = (uint8)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_UINT16:
		destValue->value_uint16 = (uint16)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_UINT32:
		destValue->value_uint32 = (uint32)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_SINT8:
		destValue->value_sint8 = (sint8)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_SINT16:
		destValue->value_sint16 = (sint16)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_SINT32:
		destValue->value_sint32 = (sint32)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_FLOAT:
		destValue->value_float = strtof(value, NULL);
		break;
	case CONFIG_VALUE_TYPE_DOUBLE:
		destValue->value_double = strtod(value, NULL);
		break;
	case CONFIG_VALUE_TYPE_STRING:
		SafeFree(destValue->value_string);
		destValue->value_string = malloc(valueSize + 1);
		memcpy(destValue->value_string, value, valueSize);
		destValue->value_string[valueSize] = 0;
		break;
	}
}

static void config_read_properties(config_section_definition **currentSection, const_utf8string line)
{
	utf8 *ch = (utf8*)line;
	utf8_skip_whitespace(&ch);

	if (*ch == '[') {
		const utf8 *sectionName;
		int sectionNameSize;
		if (config_get_section(ch, &sectionName, &sectionNameSize))
			*currentSection = config_get_section_def(sectionName, sectionNameSize);
	} else {
		if (*currentSection != NULL) {
			utf8 *propertyName, *value;
			int propertyNameSize, valueSize;
			if (config_get_property_name_value(ch, &propertyName, &propertyNameSize, &value, &valueSize)) {
				config_property_definition *property;
				property = config_get_property_def(*currentSection, propertyName, propertyNameSize);
				if (property != NULL)
					config_set_property(*currentSection, property, value, valueSize);
			}
		}
	}
}

static bool config_read_enum(void *dest, int destSize, const utf8 *key, int keySize, config_enum_definition *enumDefinitions)
{
	while (enumDefinitions->key != NULL) {
		if (strlen(enumDefinitions->key) == keySize && _strnicmp(enumDefinitions->key, key, keySize) == 0) {
			memcpy(dest, &enumDefinitions->value.value_uint32, destSize);
			return true;
		}
		enumDefinitions++;
	}
	return false;
}

static void config_write_enum(SDL_RWops *file, uint8 type, value_union *value, config_enum_definition *enumDefinitions)
{
	uint32 enumValue = (value->value_uint32) & ((1 << (_configValueTypeSize[type] * 8)) - 1);
	while (enumDefinitions->key != NULL) {
		if (enumDefinitions->value.value_uint32 == enumValue) {
			SDL_RWwrite(file, enumDefinitions->key, strlen(enumDefinitions->key), 1);
			return;
		}
		enumDefinitions++;
	}
	config_save_property_value(file, type, value);
}

static void utf8_skip_whitespace(utf8 **outch)
{
	utf8 *ch;
	while (**outch != 0) {
		ch = *outch;
		if (!isspace(utf8_get_next(*outch, (const utf8**)outch))) {
			*outch = ch;
			break;
		}
	}
}

static void utf8_skip_non_whitespace(utf8 **outch)
{
	while (**outch != 0) {
		if (isspace(utf8_get_next(*outch, (const utf8**)outch)))
			break;
	}
}

/*

Code reserved for when we want more intelligent saving of config file which preserves comments and layout

enum {
	CONFIG_LINE_TYPE_WHITESPACE,
	CONFIG_LINE_TYPE_COMMENT,
	CONFIG_LINE_TYPE_SECTION,
	CONFIG_LINE_TYPE_PROPERTY,
	CONFIG_LINE_TYPE_INVALID
};

typedef struct {
	uint8 type;
	utf8string line;
} config_line;

static config_line *_configLines = NULL;

*/

/**
 * Attempts to find the RCT2 installation directory.
 * This should be created from some other resource when OpenRCT2 grows.
 * @param resultPath Pointer to where the absolute path of the RCT2 installation directory will be copied to.
 * @returns 1 if successful, otherwise 0.
 */
static bool config_find_rct2_path(utf8 *resultPath)
{
	int i;

	log_verbose("searching common installation locations.");

	const utf8 *searchLocations[] = {
		"C:\\Program Files\\Infogrames\\RollerCoaster Tycoon 2",
		"C:\\Program Files (x86)\\Infogrames\\RollerCoaster Tycoon 2",
		"C:\\Program Files\\Infogrames Interactive\\RollerCoaster Tycoon 2",
		"C:\\Program Files (x86)\\Infogrames Interactive\\RollerCoaster Tycoon 2",
		"C:\\Program Files\\Atari\\RollerCoaster Tycoon 2",
		"C:\\Program Files (x86)\\Atari\\RollerCoaster Tycoon 2",
		"C:\\GOG Games\\RollerCoaster Tycoon 2 Triple Thrill Pack",
		gExePath
	};

	for (i = 0; i < countof(searchLocations); i++) {
		if (platform_original_game_data_exists(searchLocations[i])) {
			safe_strncpy(resultPath, searchLocations[i], MAX_PATH);
			return true;
		}
	}

	return false;
}

bool config_find_or_browse_install_directory()
{
	utf8 path[MAX_PATH];
	utf8 *installPath;

	if (config_find_rct2_path(path)) {
		SafeFree(gConfigGeneral.game_path);
		gConfigGeneral.game_path = malloc(strlen(path) + 1);
		safe_strncpy(gConfigGeneral.game_path, path, MAX_PATH);
	} else {
		platform_show_messagebox("Unable to find RCT2 installation directory. Please select the directory where you installed RCT2!");
		installPath = platform_open_directory_browser("Please select your RCT2 directory");
		if (installPath == NULL)
			return false;

		SafeFree(gConfigGeneral.game_path);
		gConfigGeneral.game_path = installPath;
	}

	return true;
}

#pragma region Obsolete

/**
 * Any code not implemented in OpenRCT2 will still uses the old configuration option addresses. This function copies all the
 * OpenRCT2 configuration options to those addresses until the process is no longer necessary.
 */
void config_apply_to_old_addresses()
{
	RCT2_GLOBAL(RCT2_ADDRESS_CONFIG_EDGE_SCROLLING, sint8) = gConfigGeneral.edge_scrolling;
	RCT2_GLOBAL(RCT2_ADDRESS_CONFIG_CURRENCY, sint8) = gConfigGeneral.currency_format;
	RCT2_GLOBAL(RCT2_ADDRESS_CONFIG_METRIC, sint8) = gConfigGeneral.measurement_format;
	RCT2_GLOBAL(RCT2_ADDRESS_CONFIG_TEMPERATURE, sint8) = gConfigGeneral.temperature_format;
	RCT2_GLOBAL(RCT2_ADDRESS_CONFIG_CONSTRUCTION_MARKER, uint8) = gConfigGeneral.construction_marker_colour;
	RCT2_GLOBAL(RCT2_ADDRESS_CONFIG_HEIGHT_MARKERS, sint16) = (gConfigGeneral.measurement_format + 1) * 256;
	if (gConfigGeneral.show_height_as_units)
		RCT2_GLOBAL(RCT2_ADDRESS_CONFIG_HEIGHT_MARKERS, sint16) = 0;

	int configFlags = 0;
	if (gConfigGeneral.always_show_gridlines)
		configFlags |= CONFIG_FLAG_ALWAYS_SHOW_GRIDLINES;
	if (!gConfigGeneral.landscape_smoothing)
		configFlags |= CONFIG_FLAG_DISABLE_SMOOTH_LANDSCAPE;
	if (gConfigGeneral.show_height_as_units)
		configFlags |= CONFIG_FLAG_SHOW_HEIGHT_AS_UNITS;
	if (gConfigGeneral.save_plugin_data)
		configFlags |= CONFIG_FLAG_SAVE_PLUGIN_DATA;

	RCT2_GLOBAL(RCT2_ADDRESS_CONFIG_FLAGS, uint8) = configFlags;
}

#pragma endregion

#pragma region Shortcuts

#define SHIFT 0x100
#define CTRL 0x200
#define ALT 0x400

// Current keyboard shortcuts
uint16 gShortcutKeys[SHORTCUT_COUNT];

// Default keyboard shortcuts
static const uint16 _defaultShortcutKeys[SHORTCUT_COUNT] = {
	SDL_SCANCODE_BACKSPACE,				// SHORTCUT_CLOSE_TOP_MOST_WINDOW
	SHIFT | SDL_SCANCODE_BACKSPACE,		// SHORTCUT_CLOSE_ALL_FLOATING_WINDOWS
	SDL_SCANCODE_ESCAPE,				// SHORTCUT_CANCEL_CONSTRUCTION_MODE
	SDL_SCANCODE_PAUSE,					// SHORTCUT_PAUSE_GAME
	SDL_SCANCODE_PAGEUP,				// SHORTCUT_ZOOM_VIEW_OUT
	SDL_SCANCODE_PAGEDOWN,				// SHORTCUT_ZOOM_VIEW_IN
	SDL_SCANCODE_RETURN,				// SHORTCUT_ROTATE_VIEW_CLOCKWISE
	SHIFT | SDL_SCANCODE_RETURN,		// SHORTCUT_ROTATE_VIEW_ANTICLOCKWISE
	SDL_SCANCODE_Z,						// SHORTCUT_ROTATE_CONSTRUCTION_OBJECT
	SDL_SCANCODE_1,						// SHORTCUT_UNDERGROUND_VIEW_TOGGLE
	SDL_SCANCODE_H,						// SHORTCUT_REMOVE_BASE_LAND_TOGGLE
	SDL_SCANCODE_V,						// SHORTCUT_REMOVE_VERTICAL_LAND_TOGGLE
	SDL_SCANCODE_3,						// SHORTCUT_SEE_THROUGH_RIDES_TOGGLE
	SDL_SCANCODE_4,						// SHORTCUT_SEE_THROUGH_SCENERY_TOGGLE
	SDL_SCANCODE_5,						// SHORTCUT_INVISIBLE_SUPPORTS_TOGGLE
	SDL_SCANCODE_6,						// SHORTCUT_INVISIBLE_PEOPLE_TOGGLE
	SDL_SCANCODE_8,						// SHORTCUT_HEIGHT_MARKS_ON_LAND_TOGGLE
	SDL_SCANCODE_9,						// SHORTCUT_HEIGHT_MARKS_ON_RIDE_TRACKS_TOGGLE
	SDL_SCANCODE_0,						// SHORTCUT_HEIGHT_MARKS_ON_PATHS_TOGGLE
	SDL_SCANCODE_F1,					// SHORTCUT_ADJUST_LAND
	SDL_SCANCODE_F2,					// SHORTCUT_ADJUST_WATER
	SDL_SCANCODE_F3,					// SHORTCUT_BUILD_SCENERY
	SDL_SCANCODE_F4,					// SHORTCUT_BUILD_PATHS
	SDL_SCANCODE_F5,					// SHORTCUT_BUILD_NEW_RIDE
	SDL_SCANCODE_F,						// SHORTCUT_SHOW_FINANCIAL_INFORMATION
	SDL_SCANCODE_D,						// SHORTCUT_SHOW_RESEARCH_INFORMATION
	SDL_SCANCODE_R,						// SHORTCUT_SHOW_RIDES_LIST
	SDL_SCANCODE_P,						// SHORTCUT_SHOW_PARK_INFORMATION
	SDL_SCANCODE_G,						// SHORTCUT_SHOW_GUEST_LIST
	SDL_SCANCODE_S,						// SHORTCUT_SHOW_STAFF_LIST
	SDL_SCANCODE_M,						// SHORTCUT_SHOW_RECENT_MESSAGES
	SDL_SCANCODE_TAB,					// SHORTCUT_SHOW_MAP
	CTRL | SDL_SCANCODE_S,				// SHORTCUT_SCREENSHOT

	// New
	SDL_SCANCODE_MINUS,					// SHORTCUT_REDUCE_GAME_SPEED,
	SDL_SCANCODE_EQUALS,				// SHORTCUT_INCREASE_GAME_SPEED,
	CTRL | ALT | SDL_SCANCODE_C,		// SHORTCUT_OPEN_CHEAT_WINDOW,
	SDL_SCANCODE_T,						// SHORTCUT_REMOVE_TOP_BOTTOM_TOOLBAR_TOGGLE,
	SDL_SCANCODE_UP,					// SHORTCUT_SCROLL_MAP_UP
	SDL_SCANCODE_LEFT,					// SHORTCUT_SCROLL_MAP_LEFT
	SDL_SCANCODE_DOWN,					// SHORTCUT_SCROLL_MAP_DOWN
	SDL_SCANCODE_RIGHT,					// SHORTCUT_SCROLL_MAP_RIGHT
	SDL_SCANCODE_C,						// SHORTCUT_OPEN_CHAT_WINDOW
	CTRL | SDL_SCANCODE_F10,			// SHORTCUT_QUICK_SAVE_GAME
	CTRL | SDL_SCANCODE_F12,			// SHORTCUT_TOGGLE_RECORDING
};

#define SHORTCUT_FILE_VERSION 1

/**
 *
 *  rct2: 0x006E3604
 */
void config_reset_shortcut_keys()
{
	memcpy(gShortcutKeys, _defaultShortcutKeys, sizeof(gShortcutKeys));
}

void config_shortcut_keys_get_path(utf8 *outPath)
{
	platform_get_user_directory(outPath, NULL);
	strcat(outPath, "hotkeys.cfg");
}

bool config_shortcut_keys_load()
{
	utf8 path[MAX_PATH];
	SDL_RWops *file;
	bool result;
	uint16 version;

	config_shortcut_keys_get_path(path);

	file = SDL_RWFromFile(path, "rb");
	if (file != NULL) {
		result = SDL_RWread(file, &version, sizeof(version), 1) == 1;
		if (result && version == SHORTCUT_FILE_VERSION) {
			result = SDL_RWread(file, gShortcutKeys, sizeof(gShortcutKeys), 1) == 1;
		} else {
			result = false;
		}
		SDL_RWclose(file);
	} else {
		result = false;
	}

	return result;
}

bool config_shortcut_keys_save()
{
	const uint16 version = SHORTCUT_FILE_VERSION;

	utf8 path[MAX_PATH];
	SDL_RWops *file;
	bool result;

	config_shortcut_keys_get_path(path);

	file = SDL_RWFromFile(path, "wb");
	if (file != NULL) {
		result = SDL_RWwrite(file, &version, sizeof(version), 1) == 1;
		if (result) {
			result = SDL_RWwrite(file, gShortcutKeys, sizeof(gShortcutKeys), 1) == 1;
		}
		SDL_RWclose(file);
	} else {
		result = false;
	}

	return result;
}

#pragma endregion


#pragma region Themes

typedef struct {
	size_t offset;
	const_utf8string property_name;
	uint8 type;
	value_union default_value;
	config_enum_definition *enum_definitions;
} theme_property_definition;

typedef struct {
	size_t offset;
	const_utf8string section_name;
	theme_property_definition *property_definitions;
	int property_definitions_count;
} theme_section_definition;


theme_property_definition _themeWindowDefinitions[] = {
	{ offsetof(theme_window, colours[0]),		"colour_0",		CONFIG_VALUE_TYPE_UINT8,	0,	NULL },
	{ offsetof(theme_window, colours[1]),		"colour_1",		CONFIG_VALUE_TYPE_UINT8,	0,	NULL },
	{ offsetof(theme_window, colours[2]),		"colour_2",		CONFIG_VALUE_TYPE_UINT8,	0,	NULL },
	{ offsetof(theme_window, colours[3]),		"colour_3",		CONFIG_VALUE_TYPE_UINT8,	0,	NULL },
	{ offsetof(theme_window, colours[4]),		"colour_4",		CONFIG_VALUE_TYPE_UINT8,	0,	NULL },
	{ offsetof(theme_window, colours[5]),		"colour_5",		CONFIG_VALUE_TYPE_UINT8,	0,	NULL },
};

theme_property_definition _themeFeaturesDefinitions[] = {
	{ offsetof(theme_features, rct1_ride_lights),		"rct1_ride_lights",			CONFIG_VALUE_TYPE_BOOLEAN,	false,	NULL },
	{ offsetof(theme_features, rct1_park_lights),		"rct1_park_lights",			CONFIG_VALUE_TYPE_BOOLEAN,	false,	NULL },
	{ offsetof(theme_features, rct1_scenario_font),		"rct1_scenario_font",		CONFIG_VALUE_TYPE_BOOLEAN,	false,	NULL },
};


theme_section_definition _themeSectionDefinitions[] = {
	// Special definition for theme windows
	{ 0,									"",				_themeWindowDefinitions,	countof(_themeWindowDefinitions)	},
	{ offsetof(theme_preset, features),		"features",		_themeFeaturesDefinitions,	countof(_themeFeaturesDefinitions)	},
};

static bool themes_open(const_utf8string path);
static bool themes_save(const_utf8string path, int preset);
static void themes_read_properties(theme_preset *theme, theme_section_definition **currentSection, utf8string line);
static void themes_set_property(theme_preset *theme, const theme_section_definition *section, const theme_property_definition *property, utf8string value, int valueSize);
static theme_section_definition* themes_get_section_def(utf8string name, int size);
static theme_property_definition *themes_get_property_def(theme_section_definition *section, utf8string name, int size);

void themes_set_default()
{
	utf8 path[MAX_PATH];

	platform_get_user_directory(path, "themes");
	platform_ensure_directory_exists(path);

	gConfigThemes.num_presets = 2;
	gConfigThemes.presets = malloc(sizeof(theme_preset) * gConfigThemes.num_presets);

	// Set RCT2 theme
	safe_strncpy(gConfigThemes.presets[0].name, language_get_string(2741), THEME_PRESET_NAME_SIZE);
	gConfigThemes.presets[0].windows = malloc(sizeof(theme_window) * gNumThemeWindows);

	// Define the defaults for RCT2 here
	gConfigThemes.presets[0].features.rct1_ride_lights = false;
	gConfigThemes.presets[0].features.rct1_park_lights = false;
	gConfigThemes.presets[0].features.rct1_scenario_font = false;


	for (int i = 0; i < (int)gNumThemeWindows; i++) {
		gConfigThemes.presets[0].windows[i] = gThemeWindowDefinitions[i].window;
	}

	// Set RCT1 theme
	safe_strncpy(gConfigThemes.presets[1].name, language_get_string(2740), THEME_PRESET_NAME_SIZE);
	gConfigThemes.presets[1].windows = malloc(sizeof(theme_window) * gNumThemeWindows);

	// Define the defaults for RCT1 here
	gConfigThemes.presets[1].features.rct1_ride_lights = true;
	gConfigThemes.presets[1].features.rct1_park_lights = true;
	gConfigThemes.presets[1].features.rct1_scenario_font = true;


	for (int i = 0; i < (int)gNumThemeWindows; i++) {
		uint8 changed_colour = 0xFF;
		for (int k = 0; gThemeWindowsRCT1[k].classification != 0xFF; k++) {
			if (gThemeWindowsRCT1[k].classification == gThemeWindowDefinitions[i].classification) {
				changed_colour = (uint8)k;
				break;
			}
		}
		gConfigThemes.presets[1].windows[i] = (changed_colour != 0xFF ? gThemeWindowsRCT1[changed_colour].window : gThemeWindowDefinitions[i].window);
		}
	}

void themes_load_presets()
{
	utf8 path[MAX_PATH];
	file_info file;
	int fileEnumHandle, i;

	platform_get_user_directory(path, "themes");
	strcat(path, "*.ini");
	fileEnumHandle = platform_enumerate_files_begin(path);
	while (platform_enumerate_files_next(fileEnumHandle, &file)) {
		platform_get_user_directory(path, "themes");
		strcat(path, file.path);
		themes_open(path);
	}
	platform_enumerate_files_end(fileEnumHandle);

	if (strcmp(gConfigInterface.current_theme_preset, "*RCT2") == 0) {
		theme_change_preset(0);
	}
	else if (strcmp(gConfigInterface.current_theme_preset, "*RCT1") == 0) {
		theme_change_preset(1);
	}
	else {
		for (i = 2; i < gConfigThemes.num_presets; i++) {
			if (strcmp(gConfigInterface.current_theme_preset, gConfigThemes.presets[i].name) == 0) {
				theme_change_preset(i);
				break;
			}
		}
		if (i == gConfigThemes.num_presets) {
			theme_change_preset(0);
		}
	}
}

bool themes_save_preset(int preset)
{
	utf8 path[MAX_PATH];

	platform_get_user_directory(path, "themes");
	strcat(path, gConfigThemes.presets[preset].name);
	strcat(path, ".ini");
	if (themes_save(path, preset)) {
		return true;
	}

	return false;
}

bool themes_open(const_utf8string path)
{
	SDL_RWops *file;
	utf8string lineBuffer;
	size_t lineBufferCapacity;
	size_t lineLength;
	int c, preset;
	theme_section_definition *currentSection;

	file = SDL_RWFromFile(path, "rb");
	if (file == NULL)
		return false;

	// Check if the colour scheme is already loaded
	// No nead to read the first two presets as they're hardcoded in
	for (preset = 2; preset < gConfigThemes.num_presets; preset++) {
		if (strcmp(path, gConfigThemes.presets[preset].name) == 0) {
			break;
		}
	}
	// Otherwise allocate one
	if (preset == gConfigThemes.num_presets) {
		gConfigThemes.num_presets++;
		gConfigThemes.presets = realloc(gConfigThemes.presets, sizeof(theme_preset) * gConfigThemes.num_presets);
		safe_strncpy(gConfigThemes.presets[preset].name, path_get_filename(path), THEME_PRESET_NAME_SIZE);
		path_remove_extension(gConfigThemes.presets[preset].name);
		gConfigThemes.presets[preset].windows = malloc(sizeof(theme_window) * gNumThemeWindows);
		gConfigThemes.presets[preset].features.rct1_ride_lights = false;
		gConfigThemes.presets[preset].features.rct1_park_lights = false;
		gConfigThemes.presets[preset].features.rct1_scenario_font = false;
		for (int i = 0; i < (int)gNumThemeWindows; i++) {
			gConfigThemes.presets[preset].windows[i] = gThemeWindowDefinitions[i].window;
		}
	}

	currentSection = NULL;
	lineBufferCapacity = 64;
	lineBuffer = malloc(lineBufferCapacity);
	lineLength = 0;

	// Skim UTF-8 byte order mark
	SDL_RWread(file, lineBuffer, 3, 1);
	if (!(lineBuffer[0] == (utf8)0xEF && lineBuffer[1] == (utf8)0xBB && lineBuffer[2] == (utf8)0xBF))
		SDL_RWseek(file, 0, SEEK_SET);

	while ((c = rwopsreadc(file)) != EOF) {
		if (c == '\n' || c == '\r') {
			lineBuffer[lineLength++] = 0;
			themes_read_properties(&gConfigThemes.presets[preset], &currentSection, (utf8string)lineBuffer);
			lineLength = 0;
		}
		else {
			lineBuffer[lineLength++] = c;
		}

		if (lineLength >= lineBufferCapacity) {
			lineBufferCapacity *= 2;
			lineBuffer = realloc(lineBuffer, lineBufferCapacity);
		}
	}

	if (lineLength > 0) {
		lineBuffer[lineLength++] = 0;
		themes_read_properties(&gConfigThemes.presets[preset], &currentSection, lineBuffer);
	}

	free(lineBuffer);
	SDL_RWclose(file);
	return true;
}

static bool themes_save(const_utf8string path, int preset)
{
	SDL_RWops *file;
	int i, j;
	value_union *value;

	file = SDL_RWFromFile(path, "wb");
	if (file == NULL) {
		log_error("Unable to write to theme file.");
		return false;
	}

	// Skip the window definition, we'll do that after
	for (i = 1; i < countof(_themeSectionDefinitions); i++) {
		theme_section_definition *section = &_themeSectionDefinitions[i];

		rwopswritec(file, '[');
		SDL_RWwrite(file, section->section_name, strlen(section->section_name), 1);
		rwopswritec(file, ']');
		rwopswritec(file, '\n');

		for (j = 0; j < section->property_definitions_count; j++) {
			theme_property_definition *property = &section->property_definitions[j];

			SDL_RWwrite(file, property->property_name, strlen(property->property_name), 1);
			SDL_RWwrite(file, " = ", 3, 1);

			value = (value_union*)((size_t)&gConfigThemes.presets[preset] + (size_t)section->offset + (size_t)property->offset);

			if (property->enum_definitions != NULL)
				config_write_enum(file, property->type, value, property->enum_definitions);
			else
				config_save_property_value(file, property->type, value);
			rwopswritec(file, '\n');
		}
		rwopswritec(file, '\n');
	}

	for (i = 0; i < (int)gNumThemeWindows; i++) {
		theme_section_definition *section = &_themeSectionDefinitions[0];

		rwopswritec(file, '[');
		SDL_RWwrite(file, gThemeWindowDefinitions[i].section_name, strlen(gThemeWindowDefinitions[i].section_name), 1);
		rwopswritec(file, ']');
		rwopswritec(file, '\n');

		for (j = 0; j < section->property_definitions_count; j++) {
			theme_property_definition *property = &section->property_definitions[j];

			SDL_RWwrite(file, property->property_name, strlen(property->property_name), 1);
			SDL_RWwrite(file, " = ", 3, 1);

			value = (value_union*)((size_t)gConfigThemes.presets[preset].windows + (size_t)(sizeof(theme_window) * i) + (size_t)property->offset);

			if (property->enum_definitions != NULL)
				config_write_enum(file, property->type, value, property->enum_definitions);
			else
				config_save_property_value(file, property->type, value);
			rwopswritec(file, '\n');
		}
	}

	SDL_RWclose(file);
	return true;
}


static void themes_read_properties(theme_preset *theme, theme_section_definition **currentSection, utf8string line)
{
	utf8 *ch = (utf8*)line;
	utf8_skip_whitespace(&ch);

	if (*ch == '[') {
		const utf8 *sectionName;
		int sectionNameSize;
		if (config_get_section(ch, &sectionName, &sectionNameSize))
			*currentSection = themes_get_section_def((utf8string)sectionName, sectionNameSize);
	} else {
		if (*currentSection != NULL) {
			utf8 *propertyName, *value;
			int propertyNameSize, valueSize;
			if (config_get_property_name_value(ch, &propertyName, &propertyNameSize, &value, &valueSize)) {
				theme_property_definition *property;
				property = themes_get_property_def(*currentSection, propertyName, propertyNameSize);
				if (property != NULL)
					themes_set_property(theme, *currentSection, property, value, valueSize);
			}
		}
	}
}
static void themes_set_property(theme_preset *theme, const theme_section_definition *section, const theme_property_definition *property, utf8string value, int valueSize)
{
	value_union *destValue = (value_union*)((size_t)theme + (size_t)section->offset + (size_t)property->offset);

	// Get getting the address from the windows pointer instead
	if (section == &_themeSectionDefinitions[0])
		destValue = (value_union*)((size_t)theme->windows + (size_t)section->offset + (size_t)property->offset);

	if (property->enum_definitions != NULL)
		if (config_read_enum(destValue, _configValueTypeSize[property->type], value, valueSize, property->enum_definitions))
			return;

	switch (property->type) {
	case CONFIG_VALUE_TYPE_BOOLEAN:
		if (_strnicmp(value, "false", valueSize) == 0) destValue->value_boolean = false;
		else if (_strnicmp(value, "true", valueSize) == 0) destValue->value_boolean = true;
		else destValue->value_boolean = strtol(value, NULL, 0) != 0;
		break;
	case CONFIG_VALUE_TYPE_UINT8:
		destValue->value_uint8 = (uint8)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_UINT16:
		destValue->value_uint16 = (uint16)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_UINT32:
		destValue->value_uint32 = (uint32)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_SINT8:
		destValue->value_sint8 = (sint8)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_SINT16:
		destValue->value_sint16 = (sint16)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_SINT32:
		destValue->value_sint32 = (sint32)strtol(value, NULL, 0);
		break;
	case CONFIG_VALUE_TYPE_FLOAT:
		destValue->value_float = strtof(value, NULL);
		break;
	case CONFIG_VALUE_TYPE_DOUBLE:
		destValue->value_double = strtod(value, NULL);
		break;
	case CONFIG_VALUE_TYPE_STRING:
		SafeFree(destValue->value_string);
		destValue->value_string = malloc(valueSize + 1);
		memcpy(destValue->value_string, value, valueSize);
		destValue->value_string[valueSize] = 0;
		break;
	}
}
static theme_section_definition* themes_get_section_def(utf8string name, int size)
{
	int i;

	// Skip the special definition
	for (i = 1; i < countof(_themeSectionDefinitions); i++) {
		const_utf8string sectionName = _themeSectionDefinitions[i].section_name;
		if (sectionName[size] == 0 && _strnicmp(sectionName, name, size) == 0)
			return &_themeSectionDefinitions[i];
	}
	// Check for window definitions
	for (i = 0; i < (int)gNumThemeWindows; i++) {
		const_utf8string sectionName = gThemeWindowDefinitions[i].section_name;
		if (sectionName[size] == 0 && _strnicmp(sectionName, name, size) == 0) {
			_themeSectionDefinitions[0].offset = (size_t)(sizeof(theme_window) * i);
			return &_themeSectionDefinitions[0];
		}
	}

	return NULL;
		}
static theme_property_definition *themes_get_property_def(theme_section_definition *section, utf8string name, int size)
{
	int i;

	for (i = 0; i < section->property_definitions_count; i++) {
		const_utf8string propertyName = section->property_definitions[i].property_name;
		if (propertyName[size] == 0 && _strnicmp(propertyName, name, size) == 0)
			return &section->property_definitions[i];
	}

	return NULL;
}

#pragma endregion

#pragma region Title Sequences

static void title_sequence_open(const char *path, const char *customName);

void title_sequences_set_default()
{
	char path[MAX_PATH];
	char sep = platform_get_path_separator();

	platform_get_user_directory(path, "title sequences");
	platform_ensure_directory_exists(path);

	gConfigTitleSequences.presets = malloc(0);
	gConfigTitleSequences.num_presets = 0;

	// Load OpenRCT2 title sequence
	sprintf(path, "%s%c%s%c%s%c%s%c", gExePath, sep, "data", sep, "title", sep, "rct2", sep);
	title_sequence_open(path, language_get_string(5308));

	// Load OpenRCT2 title sequence
	sprintf(path, "%s%c%s%c%s%c%s%c", gExePath, sep, "data", sep, "title", sep, "openrct2", sep);
	title_sequence_open(path, language_get_string(5309));
}

void title_sequences_load_presets()
{
	utf8 path[MAX_PATH], titleDir[MAX_PATH];
	int dirEnumHandle, i;

	// Find all directories in the title sequences folder
	platform_get_user_directory(path, "title sequences");
	dirEnumHandle = platform_enumerate_directories_begin(path);
	while (platform_enumerate_directories_next(dirEnumHandle, titleDir)) {
		platform_get_user_directory(path, "title sequences");
		strcat(path, titleDir);
		title_sequence_open(path, NULL);
	}
	platform_enumerate_directories_end(dirEnumHandle);

	// Check which title sequence is the current one
	if (_stricmp(gConfigInterface.current_title_sequence_preset, "*RCT2") == 0) {
		gCurrentTitleSequence = 0;
	}
	else if (_stricmp(gConfigInterface.current_title_sequence_preset, "*OPENRCT2") == 0) {
		gCurrentTitleSequence = 1;
	}
	else {
		for (i = TITLE_SEQUENCE_DEFAULT_PRESETS; i < gConfigTitleSequences.num_presets; i++) {
			if (_stricmp(gConfigInterface.current_title_sequence_preset, gConfigTitleSequences.presets[i].name) == 0) {
				gCurrentTitleSequence = i;
				break;
			}
		}
		if (i == gConfigTitleSequences.num_presets) {
			gCurrentTitleSequence = 0;
		}
	}
	gCurrentPreviewTitleSequence = gCurrentTitleSequence;
}

static void title_sequence_open(const char *path, const char *customName)
{
	utf8 titlePath[MAX_PATH], scriptPath[MAX_PATH];
	file_info fileInfo;
	SDL_RWops *file;
	int fileEnumHandle, i, preset;
	char parts[3 * 128], *token, *part1, *part2;
	char separator = platform_get_path_separator();

	// Check for the script file
	safe_strncpy(scriptPath, path, MAX_PATH);
	strcat(scriptPath, "script.txt");
	if (!platform_file_exists(scriptPath)) {
		// No script file, title sequence is invalid
		return;
	}

	// Check if the preset is already loaded
	// No nead to read the first two presets as they're hardcoded in
	for (preset = 0; preset < gConfigTitleSequences.num_presets; preset++) {
		if (_stricmp(path, gConfigTitleSequences.presets[preset].name) == 0) {
			return;
		}
	}
	// Otherwise allocate one
	if (preset == gConfigTitleSequences.num_presets) {
		gConfigTitleSequences.num_presets++;
		gConfigTitleSequences.presets = realloc(gConfigTitleSequences.presets, sizeof(title_sequence) * (size_t)gConfigTitleSequences.num_presets);

		if (customName == NULL) {
			char nameBuffer[MAX_PATH], *name;
			safe_strncpy(nameBuffer, path, MAX_PATH);
			name = nameBuffer + strlen(nameBuffer) - 1;
			while (*name == '\\' || *name == '/') {
				*name = 0;
				name--;
			}
			while (*(name - 1) != '\\' && *(name - 1) != '/') {
				name--;
			}
			safe_strncpy(gConfigTitleSequences.presets[preset].name, name, TITLE_SEQUENCE_NAME_SIZE);
			gConfigTitleSequences.presets[preset].path[0] = 0;
		}
		else {
			safe_strncpy(gConfigTitleSequences.presets[preset].name, customName, TITLE_SEQUENCE_NAME_SIZE);
			safe_strncpy(gConfigTitleSequences.presets[preset].path, path, MAX_PATH);
		}

		gConfigTitleSequences.presets[preset].saves = malloc(0);
		gConfigTitleSequences.presets[preset].commands = malloc(0);
		gConfigTitleSequences.presets[preset].num_saves = 0;
		gConfigTitleSequences.presets[preset].num_commands = 0;
	}

	// Get the save file list
	safe_strncpy(titlePath, path, MAX_PATH);
	strcat(titlePath, "*.sv6");
	fileEnumHandle = platform_enumerate_files_begin(titlePath);
	while (platform_enumerate_files_next(fileEnumHandle, &fileInfo)) {
		gConfigTitleSequences.presets[preset].num_saves++;
		gConfigTitleSequences.presets[preset].saves = realloc(gConfigTitleSequences.presets[preset].saves, sizeof(char[TITLE_SEQUENCE_MAX_SAVE_LENGTH]) * (size_t)gConfigTitleSequences.presets[preset].num_saves);
		safe_strncpy(gConfigTitleSequences.presets[preset].saves[gConfigTitleSequences.presets[preset].num_saves - 1], fileInfo.path, TITLE_SEQUENCE_MAX_SAVE_LENGTH);
		gConfigTitleSequences.presets[preset].saves[gConfigTitleSequences.presets[preset].num_saves - 1][TITLE_SEQUENCE_MAX_SAVE_LENGTH - 1] = '\0';
	}
	platform_enumerate_files_end(fileEnumHandle);
	safe_strncpy(titlePath, path, MAX_PATH);
	strcat(titlePath, "*.sc6");
	fileEnumHandle = platform_enumerate_files_begin(titlePath);
	while (platform_enumerate_files_next(fileEnumHandle, &fileInfo)) {
		gConfigTitleSequences.presets[preset].num_saves++;
		gConfigTitleSequences.presets[preset].saves = realloc(gConfigTitleSequences.presets[preset].saves, sizeof(char[TITLE_SEQUENCE_MAX_SAVE_LENGTH]) * (size_t)gConfigTitleSequences.presets[preset].num_saves);
		safe_strncpy(gConfigTitleSequences.presets[preset].saves[gConfigTitleSequences.presets[preset].num_saves - 1], fileInfo.path, TITLE_SEQUENCE_MAX_SAVE_LENGTH);
		gConfigTitleSequences.presets[preset].saves[gConfigTitleSequences.presets[preset].num_saves - 1][TITLE_SEQUENCE_MAX_SAVE_LENGTH - 1] = '\0';
	}
	platform_enumerate_files_end(fileEnumHandle);

	// Load the script file
	file = SDL_RWFromFile(scriptPath, "r");
	sint64 fileSize = SDL_RWsize(file);
	do {
		title_script_get_line(file, parts);

		token = &parts[0 * 128];
		part1 = &parts[1 * 128];
		part2 = &parts[2 * 128];
		title_command command = { 0 };
		command.command = 0xFF;

		if (token[0] != 0) {
			if (_stricmp(token, "LOAD") == 0) {
				command.command = TITLE_SCRIPT_LOAD;
				command.saveIndex = 0xFF;
				for (i = 0; i < gConfigTitleSequences.presets[preset].num_saves && command.saveIndex == 0xFF; i++) {
					if (_stricmp(part1, gConfigTitleSequences.presets[preset].saves[i]) == 0)
						command.saveIndex = i;
				}
			} else if (_stricmp(token, "LOCATION") == 0) {
				command.command = TITLE_SCRIPT_LOCATION;
				command.x = atoi(part1) & 0xFF;
				command.y = atoi(part2) & 0xFF;
			} else if (_stricmp(token, "ROTATE") == 0) {
				command.command = TITLE_SCRIPT_ROTATE;
				command.rotations = atoi(part1) & 0xFF;
			} else if (_stricmp(token, "ZOOM") == 0) {
				command.command = TITLE_SCRIPT_ZOOM;
				command.zoom = atoi(part1) & 0xFF;
			} else if (_stricmp(token, "SPEED") == 0) {
				command.command = TITLE_SCRIPT_SPEED;
				command.speed = max(1, min(4, atoi(part1) & 0xFF));
			} else if (_stricmp(token, "WAIT") == 0) {
				command.command = TITLE_SCRIPT_WAIT;
				command.seconds = atoi(part1) & 0xFF;
			} else if (_stricmp(token, "RESTART") == 0) {
				command.command = TITLE_SCRIPT_RESTART;
			} else if (_stricmp(token, "END") == 0) {
				command.command = TITLE_SCRIPT_END;
			} else if (_stricmp(token, "LOADMM") == 0) {
				command.command = TITLE_SCRIPT_LOADMM;
			}
		}
		if (command.command != 0xFF) {
			gConfigTitleSequences.presets[preset].num_commands++;
			gConfigTitleSequences.presets[preset].commands = realloc(gConfigTitleSequences.presets[preset].commands, sizeof(title_command) * (size_t)gConfigTitleSequences.presets[preset].num_commands);
			gConfigTitleSequences.presets[preset].commands[gConfigTitleSequences.presets[preset].num_commands - 1] = command;
		}
	} while (SDL_RWtell(file) < fileSize);
	SDL_RWclose(file);
}

void title_sequence_save_preset_script(int preset)
{
	utf8 path[MAX_PATH];
	SDL_RWops *file;
	int i;
	char separator = platform_get_path_separator();


	platform_get_user_directory(path, "title sequences");
	strcat(path, path_get_filename(gConfigTitleSequences.presets[preset].name));
	strncat(path, &separator, 1);
	strcat(path, "script.txt");

	file = SDL_RWFromFile(path, "wb");
	if (file == NULL) {
		log_error("Unable to write to script file.");
		return;
	}

	for (i = 0; i < gConfigTitleSequences.presets[preset].num_commands; i++) {
		title_command *command = &gConfigTitleSequences.presets[preset].commands[i];
		switch (command->command) {
		case TITLE_SCRIPT_LOAD:
			if (command->saveIndex == 0xFF)
				rwopsprintf(file, "LOAD <No save file>\r\n");
			else
				rwopsprintf(file, "LOAD %s\r\n", gConfigTitleSequences.presets[preset].saves[command->saveIndex]);
			break;
		case TITLE_SCRIPT_LOCATION:
			rwopsprintf(file, "LOCATION %i %i\r\n", command->x, command->y);
			break;
		case TITLE_SCRIPT_ROTATE:
			rwopsprintf(file, "ROTATE %i\r\n", command->rotations);
			break;
		case TITLE_SCRIPT_ZOOM:
			rwopsprintf(file, "ZOOM %i\r\n", command->zoom);
			break;
		case TITLE_SCRIPT_SPEED:
			rwopsprintf(file, "SPEED %i\r\n", command->speed);
			break;
		case TITLE_SCRIPT_WAIT:
			rwopsprintf(file, "WAIT %i\r\n\r\n", command->seconds);
			break;
		case TITLE_SCRIPT_RESTART:
			rwopsprintf(file, "RESTART\r\n");
			break;
		case TITLE_SCRIPT_END:
			rwopsprintf(file, "END\r\n");
			break;

		}
	}

	SDL_RWclose(file);
}


#pragma endregion