mirror-Super-Mario-Bros.-Remastered-Public/addons/mod_loader/api/config.gd

class_name ModLoaderConfig
extends Object
##
## Class for managing per-mod configurations.
##
## @tutorial(Creating a Mod Config Schema with JSON-Schemas): 	https://wiki.godotmodding.com/guides/modding/config_json/

const LOG_NAME := "ModLoader:Config"
const DEFAULT_CONFIG_NAME  := "default"


## Creates a new configuration for a mod.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id] ([String]): The ID of the mod.[br]
## - [param config_name] ([String]): The name of the configuration.[br]
## - [param config_data] ([Dictionary]): The configuration data to be stored.[br]
## [br]
## [b]Returns:[/b][br]
## - [ModConfig]: The created [ModConfig] object if successful, or null otherwise.
static func create_config(mod_id: String, config_name: String, config_data: Dictionary) -> ModConfig:
	var default_config: ModConfig = get_default_config(mod_id)
	if not default_config:
		ModLoaderLog.error(
			"Failed to create config \"%s\". No config schema found for \"%s\"."
			% [config_name, mod_id], LOG_NAME
		)
		return null

	# Make sure the config name is not empty
	if config_name == "":
		ModLoaderLog.error(
			"Failed to create config \"%s\". The config name cannot be empty."
			% config_name, LOG_NAME
		)
		return null

	# Make sure the config name is unique
	if ModLoaderStore.mod_data[mod_id].configs.has(config_name):
		ModLoaderLog.error(
			"Failed to create config \"%s\". A config with the name \"%s\" already exists."
			% [config_name, config_name], LOG_NAME
		)
		return null

	# Create the config save path based on the config_name
	var config_file_path := _ModLoaderPath.get_path_to_mod_configs_dir(mod_id).path_join("%s.json" % config_name)
	# Initialize a new ModConfig object with the provided parameters
	var mod_config := ModConfig.new(
		mod_id,
		config_data,
		config_file_path
	)

	# Check if the mod_config is valid
	if not mod_config.is_valid:
		return null

	# Store the mod_config in the mod's ModData
	ModLoaderStore.mod_data[mod_id].configs[config_name] = mod_config
	# Save the mod_config to a new config JSON file in the mod's config directory
	var is_save_success := mod_config.save_to_file()

	if not is_save_success:
		return null

	ModLoaderLog.debug("Created new config \"%s\" for mod \"%s\"" % [config_name, mod_id], LOG_NAME)

	return mod_config


## Updates an existing [ModConfig] object with new data and saves the config file.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param config] ([ModConfig]): The [ModConfig] object to be updated.[br]
## [br]
## [b]Returns:[/b][br]
## - [ModConfig]: The updated [ModConfig] object if successful, or null otherwise.
static func update_config(config: ModConfig) -> ModConfig:
	# Validate the config and check for any validation errors
	var error_message := config.validate()

	# Check if the config is the "default" config, which cannot be modified
	if config.name == DEFAULT_CONFIG_NAME:
		ModLoaderLog.error("The \"default\" config cannot be modified. Please create a new config instead.", LOG_NAME)
		return null

	# Check if the config passed validation
	if not config.is_valid:
		ModLoaderLog.error("Update for config \"%s\" failed validation with error message \"%s\"" % [config.name, error_message], LOG_NAME)
		return null

	# Save the updated config to the config file
	var is_save_success := config.save_to_file()

	if not is_save_success:
		ModLoaderLog.error("Failed to save config \"%s\" to \"%s\"." % [config.name, config.save_path], LOG_NAME)
		return null

	# Return the updated config
	return config


## Deletes a [ModConfig] object and performs cleanup operations.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param config] ([ModConfig]): The [ModConfig] object to be deleted.[br]
## [br]
## [b]Returns:[/b][br]
## - [bool]: True if the deletion was successful, False otherwise.
static func delete_config(config: ModConfig) -> bool:
	# Check if the config is the "default" config, which cannot be deleted
	if config.name == DEFAULT_CONFIG_NAME:
		ModLoaderLog.error("Deletion of the default configuration is not allowed.", LOG_NAME)
		return false

	# Change the current config to the "default" config
	set_current_config(get_default_config(config.mod_id))
	# Remove the config file from the Mod Config directory
	var is_remove_success := config.remove_file()

	if not is_remove_success:
		return false

	# Remove the config from ModData
	ModLoaderStore.mod_data[config.mod_id].configs.erase(config.name)

	return true


## Sets the current configuration of a mod to the specified configuration.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param config] ([ModConfig]): The [ModConfig] object to be set as current config.
static func set_current_config(config: ModConfig) -> void:
	ModLoaderStore.mod_data[config.mod_id].current_config = config


## Returns the schema for the specified mod id.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id] ([String]): The ID of the mod.[br]
## [br]
## [b]Returns:[/b][br]
## - A dictionary representing the schema for the mod's configuration file.
static func get_config_schema(mod_id: String) -> Dictionary:
	# Get all config files for the specified mod
	var mod_configs := get_configs(mod_id)

	# If no config files were found, return an empty dictionary
	if mod_configs.is_empty():
		return {}

	# The schema is the same for all config files, so we just return the schema of the default config file
	return mod_configs.default.schema


## Retrieves the schema for a specific property key.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param config] ([ModConfig]): The [ModConfig] object from which to retrieve the schema.[br]
## - [param prop] ([String]): The property key for which to retrieve the schema.[br]
## [br]
## [b]Returns:[/b][br]
## - [Dictionary]: The schema dictionary for the specified property.
static func get_schema_for_prop(config: ModConfig, prop: String) -> Dictionary:
	# Split the property string into an array of property keys
	var prop_array := prop.split(".")

	# If the property array is empty, return the schema for the root property
	if prop_array.is_empty():
		return config.schema.properties[prop]

	# Traverse the schema dictionary to find the schema for the specified property
	var schema_for_prop := _traverse_schema(config.schema.properties, prop_array)

	# If the schema for the property is empty, log an error and return an empty dictionary
	if schema_for_prop.is_empty():
		ModLoaderLog.error("No Schema found for property \"%s\" in config \"%s\" for mod \"%s\"" % [prop, config.name, config.mod_id], LOG_NAME)
		return {}

	return schema_for_prop


# Recursively traverses the schema dictionary based on the provided [code]prop_key_array[/code]
# and returns the corresponding schema for the target property.[br]
# [br]
# [b]Parameters:[/b][br]
# - [param schema_prop]: The current schema dictionary to traverse.[br]
# - [param prop_key_array]: An array containing the property keys representing the path to the target property.[br]
# [br]
# [b]Returns:[/b][br]
# - [Dictionary]: The schema dictionary corresponding to the target property specified by the [code]prop_key_array[/code].
# If the target property is not found, an empty dictionary is returned.
static func _traverse_schema(schema_prop: Dictionary, prop_key_array: Array) -> Dictionary:
	# Return the current schema_prop if the prop_key_array is empty (reached the destination property)
	if prop_key_array.is_empty():
		return schema_prop

	# Get and remove the first prop_key in the array
	var prop_key: String = prop_key_array.pop_front()

	# Check if the searched property exists
	if not schema_prop.has(prop_key):
		return {}

	schema_prop = schema_prop[prop_key]

	# If the schema_prop has a 'type' key, is of type 'object', and there are more property keys remaining
	if schema_prop.has("type") and schema_prop.type == "object" and not prop_key_array.is_empty():
		# Set the properties of the object as the current 'schema_prop'
		schema_prop = schema_prop.properties

	schema_prop = _traverse_schema(schema_prop, prop_key_array)

	return schema_prop


## Retrieves an Array of mods that have configuration files.[br]
## [br]
## [b]Returns:[/b][br]
## - [Array]: An Array containing the mod data of mods that have configuration files.
static func get_mods_with_config() -> Array:
	# Create an empty array to store mods with configuration files
	var mods_with_config := []

	# Iterate over each mod in ModLoaderStore.mod_data
	for mod_id in ModLoaderStore.mod_data:
		# Retrieve the mod data for the current mod ID
		# *The ModData type cannot be used because ModData is not fully loaded when this code is executed.*
		var mod_data = ModLoaderStore.mod_data[mod_id]

		# Check if the mod has any configuration files
		if not mod_data.configs.is_empty():
			mods_with_config.push_back(mod_data)

	# Return the array of mods with configuration files
	return mods_with_config


## Retrieves the configurations dictionary for a given mod ID.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id]: The ID of the mod.[br]
## [br]
## [b]Returns:[/b][br]
## - [Dictionary]: A dictionary containing the configurations for the specified mod.
## If the mod ID is invalid or no configurations are found, an empty dictionary is returned.
static func get_configs(mod_id: String) -> Dictionary:
	# Check if the mod ID is invalid
	if not ModLoaderStore.mod_data.has(mod_id):
		ModLoaderLog.fatal("Mod ID \"%s\" not found" % [mod_id], LOG_NAME)
		return {}

	var config_dictionary: Dictionary = ModLoaderStore.mod_data[mod_id].configs

	# Check if there is no config file for the mod
	if config_dictionary.is_empty():
		ModLoaderLog.debug("No config for mod id \"%s\"" % mod_id, LOG_NAME, true)
		return {}

	return config_dictionary


## Retrieves the configuration for a specific mod and configuration name.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id] ([String]): The ID of the mod.[br]
## - [param config_name] ([String]): The name of the configuration.[br]
## [br]
## [b]Returns:[/b][br]
## - [ModConfig]: The configuration as a [ModConfig] object or null if not found.
static func get_config(mod_id: String, config_name: String) -> ModConfig:
	var configs := get_configs(mod_id)

	if not configs.has(config_name):
		ModLoaderLog.error("No config with name \"%s\" found for mod_id \"%s\" " % [config_name, mod_id], LOG_NAME)
		return null

	return configs[config_name]


## Checks whether a mod has a current configuration set.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id] ([String]): The ID of the mod.[br]
## [br]
## [b]Returns:[/b][br]
## - [bool]: True if the mod has a current configuration, false otherwise.
static func has_current_config(mod_id: String) -> bool:
	var mod_data := ModLoaderMod.get_mod_data(mod_id)
	return not mod_data.current_config == null


## Checks whether a mod has a configuration with the specified name.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id] ([String]): The ID of the mod.[br]
## - [param config_name] ([String]): The name of the configuration.[br]
## [br]
## [b]Returns:[/b][br]
## - [bool]: True if the mod has a configuration with the specified name, False otherwise.
static func has_config(mod_id: String, config_name: String) -> bool:
	var mod_data := ModLoaderMod.get_mod_data(mod_id)
	return mod_data.configs.has(config_name)


## Retrieves the default configuration for a specified mod ID.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id] ([String]): The ID of the mod.[br]
## [br]
## [b]Returns:[/b][br]
## - [ModConfig]: The [ModConfig] object representing the default configuration for the specified mod.
## If the mod ID is invalid or no configuration is found, returns null.
static func get_default_config(mod_id: String) -> ModConfig:
	return get_config(mod_id, DEFAULT_CONFIG_NAME)


## Retrieves the currently active configuration for a specific mod.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id] ([String]): The ID of the mod.[br]
## [br]
## [b]Returns:[/b][br]
## - [ModConfig]: The configuration as a [ModConfig] object or [code]null[/code] if not found.
static func get_current_config(mod_id: String) -> ModConfig:
	var current_config_name := get_current_config_name(mod_id)
	var current_config: ModConfig

	# Load the default configuration if there is no configuration set as current yet
	# Otherwise load the corresponding configuration
	if current_config_name.is_empty():
		current_config = get_default_config(mod_id)
	else:
		current_config = get_config(mod_id, current_config_name)

	return current_config


## Retrieves the name of the current configuration for a specific mod.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param mod_id] ([String]): The ID of the mod.[br]
## [br]
## [b]Returns:[/b][br]
## - [String] The currently active configuration name for the given mod id or an empty string if not found.
static func get_current_config_name(mod_id: String) -> String:
	# Check if user profile has been loaded
	if not ModLoaderStore.current_user_profile or not ModLoaderStore.user_profiles.has(ModLoaderStore.current_user_profile.name):
		# Warn and return an empty string if the user profile has not been loaded
		ModLoaderLog.warning("Can't get current mod config name for \"%s\", because no current user profile is present." % mod_id, LOG_NAME)
		return ""

	# Retrieve the current user profile from ModLoaderStore
	# *Can't use ModLoaderUserProfile because it causes a cyclic dependency*
	var current_user_profile = ModLoaderStore.current_user_profile

	# Check if the mod exists in the user profile's mod list and if it has a current config
	if not current_user_profile.mod_list.has(mod_id) or not current_user_profile.mod_list[mod_id].has("current_config"):
		# Log an error and return an empty string if the mod has no config file
		ModLoaderLog.error("Can't get current mod config name for \"%s\" because no config file exists." % mod_id, LOG_NAME)
		return ""

	# Return the name of the current configuration for the mod
	return current_user_profile.mod_list[mod_id].current_config


## Refreshes the data of the provided configuration by reloading it from the config file.[br]
## [br]
## [b]Parameters:[/b][br]
## - [param config] ([ModConfig]): The [ModConfig] object whose data needs to be refreshed.[br]
## [br]
## [b]Returns:[/b][br]
## - [ModConfig]: The [ModConfig] object with refreshed data if successful, or the original object otherwise.
static func refresh_config_data(config: ModConfig) -> ModConfig:
	# Retrieve updated configuration data from the config file
	var new_config_data := _ModLoaderFile.get_json_as_dict(config.save_path)
	# Update the data property of the ModConfig object with the refreshed data
	config.data = new_config_data

	return config


## Iterates over all mods to refresh the data of their current configurations, if available.[br]
## [br]
## [b]Returns:[/b][br]
## - No return value[br]
## [br]
## Compares the previous configuration data with the refreshed data and emits the [signal ModLoader.current_config_changed]
## signal if changes are detected.[br]
## This function ensures that any changes made to the configuration files outside the application
## are reflected within the application's runtime, allowing for dynamic updates without the need for a restart.
static func refresh_current_configs() -> void:
	for mod_id in ModLoaderMod.get_mod_data_all().keys():
		# Skip if the mod has no config
		if not has_current_config(mod_id):
			return

		# Retrieve the current configuration for the mod
		var config := get_current_config(mod_id)
		# Create a deep copy of the current configuration data for comparison
		var config_data_previous := config.data.duplicate(true)
		# Refresh the configuration data
		var config_new := refresh_config_data(config)

		# Compare previous data with refreshed data
		if not config_data_previous == config_new.data:
			# Emit signal indicating that the current configuration has changed
			ModLoader.current_config_changed.emit(config)