#include "settings.h"

static void print_config_error(GError *error) {
	if (error == NULL) return;

	if (!g_error_matches(error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND) && !g_error_matches(error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_GROUP_NOT_FOUND)) {
		g_warning("Config error: %s", error->message);
	}
}

void _print_config(config_t *config, GLogLevelFlags log_level) {
#define EXPAND_GROUP(group_name, members) \
	g_log(G_LOG_DOMAIN, log_level, "[%s]", #group_name); \
	members

#define EXPAND_GROUP_MEMBER(member, key_type, default_value) \
	g_log(G_LOG_DOMAIN, log_level, "%s="FORMAT_FOR_KEY_TYPE(key_type)"", #member, config->member);

	EXPAND_CONFIG

#undef EXPAND_GROUP
#undef EXPAND_GROUP_MEMBER
}

void load_config_from_key_file(config_t *config, GKeyFile *key_file) {
	g_message("Loading config from key file");
	GError *error = NULL;
	gchar *group_name;

#define EXPAND_GROUP(name, members) \
	group_name = #name; \
	members

#define EXPAND_GROUP_MEMBER(member, key_type, default_value) \
	config->member = g_key_file_get_##key_type(key_file, group_name, #member, &error); \
	if (error != NULL) { \
		config->member = default_value; \
		print_config_error(error); \
		g_clear_error(&error); \
	}

	EXPAND_CONFIG

	if (config->rewind_duration > 600) {
		g_warning("Setting Emulation.rewind_duration too high might affect performance.");
	}

#undef EXPAND_GROUP
#undef EXPAND_GROUP_MEMBER
}

void print_config(config_t *config) {
	_print_config(config, G_LOG_LEVEL_MESSAGE);
}

void save_config_to_key_file(config_t *config, GKeyFile *key_file) {
	g_message("Saving config to key file");
	GError *error = NULL;
	gchar *group_name;

#define EXPAND_GROUP(name, members) \
	group_name = #name; \
	members

#define EXPAND_GROUP_MEMBER_IF_0(member, key_type, default_value) \
	g_key_file_set_##key_type(key_file, group_name, #member, config->member);

#define EXPAND_GROUP_MEMBER_IF_1(member, key_type, default_value) \
	if (config->member != NULL) { \
		g_key_file_set_##key_type(key_file, group_name, #member, config->member); \
	} \
	else if (g_key_file_has_key(key_file, group_name, #member, &error)) { \
		if (error != NULL) { \
			g_warning("%s", error->message); \
			g_clear_error(&error); \
		} \
		g_key_file_remove_key(key_file, group_name, #member, &error); \
		if (error != NULL) { \
			g_warning("%s", error->message); \
			g_clear_error(&error); \
		} \
	}

#define EXPAND_GROUP_MEMBER_IF_EVAL(y, member, key_type, default_value) EXPAND_GROUP_MEMBER_IF_ ## y(member, key_type, default_value)
#define EXPAND_GROUP_MEMBER_IF(member, key_type, is_pointer, default_value) EXPAND_GROUP_MEMBER_IF_EVAL(is_pointer, member, key_type, default_value)
#define EXPAND_GROUP_MEMBER(member, key_type, default_value) EXPAND_GROUP_MEMBER_IF(member, key_type, GTYPE_IS_POINTER(key_type), default_value)
	
	EXPAND_CONFIG

#undef EXPAND_GROUP
#undef EXPAND_GROUP_MEMBER
#undef EXPAND_GROUP_MEMBER_IF
#undef EXPAND_GROUP_MEMBER_IF_EVAL
#undef EXPAND_GROUP_MEMBER_IF_0
#undef EXPAND_GROUP_MEMBER_IF_1
}

void on_preferences_realize(GtkWidget *w, gpointer builder_ptr) {
	GtkWindow *preferences = GTK_WINDOW(w);
	GtkBuilder *builder = (GtkBuilder *) builder_ptr;
	
	update_boot_rom_selector(builder);

	// Hook up the static preferences
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "rewind_duration_selector"), itoa(config.rewind_duration));
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "dmg_revision_selector"), config.dmg_revision_name);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "sgb_revision_selector"), config.sgb_revision_name);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "cgb_revision_selector"), config.cgb_revision_name);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "shader_selector"), config.shader);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "color_correction_selector"), config.color_correction_id);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "frame_blending_selector"), config.frame_blending_mode);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "display_border_selector"), config.display_border_mode);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "monochrome_palette_selector"), config.monochrome_palette_id);
	gtk_toggle_button_set_active(builder_get(GTK_TOGGLE_BUTTON, "integer_scaling_toggle"), config.use_integer_scaling);
	gtk_toggle_button_set_active(builder_get(GTK_TOGGLE_BUTTON, "aspect_ratio_toggle"), config.keep_aspect_ratio);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "highpass_filter_selector"), config.high_pass_filter_id);
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "sample_rate_selector"), itoa(config.sample_rate));
	
#if ! NDEBUG
	gtk_combo_box_set_active_id(builder_get(GTK_COMBO_BOX, "menubar_override_selector"), config.menubar_override);
#else
	if (builder_get(GTK_COMBO_BOX, "menubar_override_selector") != NULL) {
		gtk_widget_destroy(GTK_WIDGET(builder_get(GTK_COMBO_BOX, "menubar_override_selector")));
		gtk_widget_destroy(GTK_WIDGET(builder_get(GTK_COMBO_BOX, "menubar_override_selector_label")));
	}
#endif
}

void init_settings(gchar *path, GtkWindow *preferences) {
	free_settings();
	key_file = g_key_file_new();

	if (path != NULL) {
		settings_file_path = path;
	}
	else {
		settings_file_path = g_build_filename(g_get_user_config_dir(), SETTINGS_FILE, NULL);
	}

	load_settings();
}

int load_settings(void) {
	GError *error = NULL;

	g_message("Trying to load settings from %s", settings_file_path);

	if (!g_key_file_load_from_file(key_file, settings_file_path, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error)) {
		if (error->domain == G_FILE_ERROR) {
			g_warning("Unable to load %s: %s", settings_file_path, error->message);
		}
		else if (error->domain == G_KEY_FILE_ERROR) {
			g_warning("Failed to parse %s: %s", settings_file_path, error->message);
		}

		g_error_free(error);
	}

	load_config_from_key_file(&config, key_file);
	_print_config(&config, G_LOG_LEVEL_DEBUG);

	return 0;
}

void save_settings(void) {
	GError *error = NULL;

	g_message("Trying to save settings to %s", settings_file_path);
	
	save_config_to_key_file(&config, key_file);

	if (!g_key_file_save_to_file(key_file, settings_file_path, &error)) {
		g_warning ("Failed to save %s: %s", settings_file_path, error->message);
		g_error_free(error);
		return;
	}
}

void free_settings(void) {
	if (key_file != NULL) {
		g_key_file_free(key_file);
		key_file = NULL;
	}
}

void update_boot_rom_selector(GtkBuilder *builder) {
	GtkComboBoxText *combo_box = builder_get(GTK_COMBO_BOX_TEXT, "boot_rom_selector");
	gtk_combo_box_text_remove_all(combo_box);
	gtk_combo_box_text_append(combo_box, "auto", "Use Built-in Boot ROMs");
	if (config.boot_rom_path != NULL && !g_str_equal(config.boot_rom_path, "auto") && !g_str_equal(config.boot_rom_path, "other")) {
		gtk_combo_box_text_append(combo_box, config.boot_rom_path, config.boot_rom_path);
		gtk_combo_box_set_active_id(GTK_COMBO_BOX(combo_box), config.boot_rom_path);
	}
	else {
		gtk_combo_box_set_active_id(GTK_COMBO_BOX(combo_box), "auto");
	}
	gtk_combo_box_text_append_text(combo_box, "<separator>");
	gtk_combo_box_text_append(combo_box, "other", "Other");
}

enum menubar_type_t get_show_menubar(void) {
	if (config.menubar_override == NULL) goto default_value;

	if (g_strcmp0(config.menubar_override, "auto") == 0) {
		return MENUBAR_AUTO;
	}
	else if (g_strcmp0(config.menubar_override, "show_in_shell") == 0) {
		return MENUBAR_SHOW_IN_SHELL;
	}
	else if (g_strcmp0(config.menubar_override, "show_in_window") == 0) {
		return MENUBAR_SHOW_IN_WINDOW;
	}
	else if (g_strcmp0(config.menubar_override, "show_hamburger") == 0) {
		return MENUBAR_SHOW_HAMBURGER;
	}

	// This should not happen
	g_warning("Unknown menubar setting: %s\nFalling back to “Auto”", config.menubar_override);
	default_value: return MENUBAR_AUTO;
}

void set_show_menubar(enum menubar_type_t value) {
	switch (value) {
		case MENUBAR_AUTO:
			config.menubar_override = "auto";
			break;
		case MENUBAR_SHOW_IN_SHELL:
			config.menubar_override = "show_in_shell";
			break;
		case MENUBAR_SHOW_IN_WINDOW:
			config.menubar_override = "show_in_window";
			break;
		case MENUBAR_SHOW_HAMBURGER:
			config.menubar_override = "show_hamburger";
			break;
	}
}

GB_color_correction_mode_t get_color_correction_mode(void) {
	if (config.color_correction_id == NULL) goto default_value;

	if (g_strcmp0(config.color_correction_id, "disabled") == 0) {
		return GB_COLOR_CORRECTION_DISABLED;
	}
	else if (g_strcmp0(config.color_correction_id, "correct_color_curves") == 0) {
		return GB_COLOR_CORRECTION_CORRECT_CURVES;
	}
	else if (g_strcmp0(config.color_correction_id, "emulate_hardware") == 0) {
		return GB_COLOR_CORRECTION_EMULATE_HARDWARE;
	}
	else if (g_strcmp0(config.color_correction_id, "preserve_brightness") == 0) {
		return GB_COLOR_CORRECTION_PRESERVE_BRIGHTNESS;
	}
	else if (g_strcmp0(config.color_correction_id, "reduce_contrast") == 0) {
		return GB_COLOR_CORRECTION_REDUCE_CONTRAST;
	}

	// This should not happen
	g_warning("Unknown color correction mode: %s\nFalling back to “Emulate Hardware”", config.color_correction_id);
	default_value: return GB_COLOR_CORRECTION_EMULATE_HARDWARE;
}

void set_color_correction_mode(GB_color_correction_mode_t mode) {
	switch (mode) {
		case GB_COLOR_CORRECTION_DISABLED:
			config.color_correction_id = "disabled";
			break;
		case GB_COLOR_CORRECTION_CORRECT_CURVES:
			config.color_correction_id = "correct_color_curves";
			break;
		case GB_COLOR_CORRECTION_EMULATE_HARDWARE:
			config.color_correction_id = "emulate_hardware";
			break;
		case GB_COLOR_CORRECTION_PRESERVE_BRIGHTNESS:
			config.color_correction_id = "preserve_brightness";
			break;
		case GB_COLOR_CORRECTION_REDUCE_CONTRAST:
			config.color_correction_id = "reduce_contrast";
			break;
	}
}

GB_frame_blending_mode_t get_frame_blending_mode(void) {
	if (config.frame_blending_mode == NULL) goto default_value;

	if (g_strcmp0(config.frame_blending_mode, "disabled") == 0) {
		return GB_FRAME_BLENDING_MODE_DISABLED;
	}
	else if (g_strcmp0(config.frame_blending_mode, "simple") == 0) {
		return GB_FRAME_BLENDING_MODE_SIMPLE;
	}
	else if (g_strcmp0(config.frame_blending_mode, "accurate") == 0) {
		return GB_FRAME_BLENDING_MODE_ACCURATE;
	}

	// This should not happen
	g_warning("Unknown frame blending mode: %s\nFalling back to “Disabled”", config.frame_blending_mode);
	default_value: return GB_FRAME_BLENDING_MODE_DISABLED;
}

void set_frame_blending_mode(GB_frame_blending_mode_t mode) {
	switch (mode) {
		case GB_FRAME_BLENDING_MODE_DISABLED:
			config.frame_blending_mode = "disabled";
			break;
		case GB_FRAME_BLENDING_MODE_SIMPLE:
			config.frame_blending_mode = "simple";
			break;
		case GB_FRAME_BLENDING_MODE_ACCURATE:
		case GB_FRAME_BLENDING_MODE_ACCURATE_ODD:
			config.frame_blending_mode = "accurate";
			break;
	}
}

GB_border_mode_t get_display_border_mode(void) {
	if (config.display_border_mode == NULL) goto default_value;

	if (g_strcmp0(config.display_border_mode, "never") == 0) {
		return GB_BORDER_NEVER;
	}
	else if (g_strcmp0(config.display_border_mode, "sgb_only") == 0) {
		return GB_BORDER_SGB;
	}
	else if (g_strcmp0(config.display_border_mode, "always") == 0) {
		return GB_BORDER_ALWAYS;
	}

	// This should not happen
	g_warning("Unknown SGB border mode: %s\nFalling back to “Never”", config.display_border_mode);
	default_value: return GB_BORDER_NEVER;
}

void set_display_border_mode(GB_border_mode_t mode) {
	switch (mode) {
		case GB_BORDER_NEVER:
			config.display_border_mode = "never";
			break;
		case GB_BORDER_SGB:
			config.display_border_mode = "sgb_only";
			break;
		case GB_BORDER_ALWAYS:
			config.display_border_mode = "always";
			break;
	}
}

const GB_palette_t* get_monochrome_palette(void) {
	if (config.monochrome_palette_id == NULL) goto default_value;

	if (g_strcmp0(config.monochrome_palette_id, "greyscale") == 0) {
		return &GB_PALETTE_GREY;
	}
	else if (g_strcmp0(config.monochrome_palette_id, "lime") == 0) {
		return &GB_PALETTE_DMG;
	}
	else if (g_strcmp0(config.monochrome_palette_id, "olive") == 0) {
		return &GB_PALETTE_MGB;
	}
	else if (g_strcmp0(config.monochrome_palette_id, "teal") == 0) {
		return &GB_PALETTE_GBL;
	}

	// This should not happen
	g_warning("Unknown monochrome palette: %s\nFalling back to “Greyscale”", config.monochrome_palette_id);
	default_value: return &GB_PALETTE_GREY;
}

void set_monochrome_palette(const GB_palette_t *mode) {
	g_message("%p | %p | %p | %p | %p", mode, &GB_PALETTE_GREY, &GB_PALETTE_DMG, &GB_PALETTE_MGB, &GB_PALETTE_GBL);

	if (mode == &GB_PALETTE_GREY) {
		config.monochrome_palette_id = "greyscale";
	}
	else if (mode == &GB_PALETTE_DMG) {
		config.monochrome_palette_id = "lime";
	}
	else if (mode == &GB_PALETTE_MGB) {
		config.monochrome_palette_id = "olive";
	}
	else if (mode == &GB_PALETTE_GBL) {
		config.monochrome_palette_id = "teal";
	}
}

GB_highpass_mode_t get_highpass_mode(void) {
	if (config.high_pass_filter_id == NULL) goto default_value;

	if (g_strcmp0(config.high_pass_filter_id, "disabled") == 0) {
		return GB_HIGHPASS_OFF;
	}
	else if (g_strcmp0(config.high_pass_filter_id, "emulate_hardware") == 0) {
		return GB_HIGHPASS_ACCURATE;
	}
	else if (g_strcmp0(config.high_pass_filter_id, "preserve_waveform") == 0) {
		return GB_HIGHPASS_REMOVE_DC_OFFSET;
	}

	// This should not happen
	g_warning("Unknown highpass mode: %s\nFalling back to “Accurate”", config.high_pass_filter_id);
	default_value: return GB_HIGHPASS_ACCURATE;
}

void set_highpass_mode(GB_highpass_mode_t mode) {
	switch (mode) {
		case GB_HIGHPASS_OFF:
			config.high_pass_filter_id = "disabled";
			break;
		case GB_HIGHPASS_MAX:
			g_warning("GB_HIGHPASS_MAX is not a valid highpass mode, falling back to “Accurate”.");
		case GB_HIGHPASS_ACCURATE:
			config.high_pass_filter_id = "emulate_hardware";
			break;
		case GB_HIGHPASS_REMOVE_DC_OFFSET:
			config.high_pass_filter_id = "preserve_waveform";
			break;
	}
}

GB_model_t get_dmg_model(void) {
	if (config.dmg_revision_name == NULL) goto default_value;

	// TODO: Synchronize with GB_model_t (Core/gb.h)
	if (g_strcmp0(config.dmg_revision_name, "DMG_CPU_B") == 0) {
		return GB_MODEL_DMG_B;
	}

	default_value: return GB_MODEL_DMG_B;
}

GB_model_t get_sgb_model(void) {
	if (config.sgb_revision_name == NULL) goto default_value;

	// TODO: Synchronize with GB_model_t (Core/gb.h)
	if (g_strcmp0(config.sgb_revision_name, "SGB1_NTSC") == 0) {
		return GB_MODEL_SGB_NTSC;
	}
	else if (g_strcmp0(config.sgb_revision_name, "SGB1_PAL") == 0) {
		return GB_MODEL_SGB_PAL;
	}
	else if (g_strcmp0(config.sgb_revision_name, "SGB2") == 0) {
		return GB_MODEL_SGB2;
	}

	default_value: return GB_MODEL_SGB2;
}

GB_model_t get_cgb_model(void) {
	if (config.cgb_revision_name == NULL) goto default_value;

	// TODO: Synchronize with GB_model_t (Core/gb.h)
	if (g_strcmp0(config.cgb_revision_name, "CPU_CGB_C") == 0) {
		return GB_MODEL_CGB_C;
	}
	else if (g_strcmp0(config.cgb_revision_name, "CPU_CGB_E") == 0) {
		return GB_MODEL_CGB_E;
	}

	default_value: return GB_MODEL_CGB_E;
}
