class_name ModManifest
extends Resource
##
## Stores and validates contents of the manifest set by the user


const LOG_NAME := "ModLoader:ModManifest"

# Validated by [method is_name_or_namespace_valid]
## Mod name.
var name := ""
# Validated by [method is_name_or_namespace_valid]
## Mod namespace, most commonly the main author.
var mod_namespace := ""
# Validated by [method is_semver_valid]
## Semantic version. Not a number, but required to be named like this by Thunderstore
var version_number := "0.0.0"
var description := ""
var website_url := ""
## Used to determine mod load order
var dependencies: PackedStringArray = []
## Used to determine mod load order
var optional_dependencies: PackedStringArray = []
## only used for information
var authors: PackedStringArray = []
## only used for information
var compatible_game_version: PackedStringArray = []
# Validated by [method _handle_compatible_mod_loader_version]
## only used for information
var compatible_mod_loader_version: PackedStringArray = []
## only used for information
var incompatibilities: PackedStringArray = []
## Used to determine mod load order
var load_before: PackedStringArray = []
## only used for information
var tags : PackedStringArray = []
## Schema for mod configs
var config_schema := {}
var description_rich := ""
var image: CompressedTexture2D
## only used for information
var steam_workshop_id := ""

var validation_messages_error : Array[String] = []
var validation_messages_warning : Array[String] = []

var is_valid := false
var has_parsing_failed := false

# Required keys in a mod's manifest.json file
const REQUIRED_MANIFEST_KEYS_ROOT: Array[String] = [
	"name",
	"namespace",
	"version_number",
	"website_url",
	"description",
	"dependencies",
	"extra",
]

# Required keys in manifest's `json.extra.godot`
const REQUIRED_MANIFEST_KEYS_EXTRA: Array[String] = [
	"authors",
	"compatible_mod_loader_version",
	"compatible_game_version",
]


# Takes the manifest as [Dictionary] and validates everything.
# Will return null if something is invalid.
func _init(manifest: Dictionary, path: String) -> void:
	if manifest.is_empty():
		validation_messages_error.push_back("The manifest cannot be validated due to missing data, most likely because parsing the manifest.json file failed.")
		has_parsing_failed = true
	else:
		is_valid = validate(manifest, path)


func validate(manifest: Dictionary, path: String) -> bool:
	var missing_fields: Array[String] = []

	missing_fields.append_array(ModLoaderUtils.get_missing_dict_fields(manifest, REQUIRED_MANIFEST_KEYS_ROOT))
	missing_fields.append_array(ModLoaderUtils.get_missing_dict_fields(manifest.extra, ["godot"]))
	missing_fields.append_array(ModLoaderUtils.get_missing_dict_fields(manifest.extra.godot, REQUIRED_MANIFEST_KEYS_EXTRA))

	if not missing_fields.is_empty():
		validation_messages_error.push_back("Manifest is missing required fields: %s" % str(missing_fields))

	name = manifest.name
	mod_namespace = manifest.namespace
	version_number = manifest.version_number

	is_name_or_namespace_valid(name)
	is_name_or_namespace_valid(mod_namespace)

	var mod_id = get_mod_id()

	is_semver_valid(mod_id, version_number, "version_number")

	description = manifest.description
	website_url = manifest.website_url
	dependencies = manifest.dependencies

	var godot_details: Dictionary = manifest.extra.godot
	authors = ModLoaderUtils.get_array_from_dict(godot_details, "authors")
	optional_dependencies = ModLoaderUtils.get_array_from_dict(godot_details, "optional_dependencies")
	incompatibilities = ModLoaderUtils.get_array_from_dict(godot_details, "incompatibilities")
	load_before = ModLoaderUtils.get_array_from_dict(godot_details, "load_before")
	compatible_game_version = ModLoaderUtils.get_array_from_dict(godot_details, "compatible_game_version")
	compatible_mod_loader_version = _handle_compatible_mod_loader_version(mod_id, godot_details)
	description_rich = ModLoaderUtils.get_string_from_dict(godot_details, "description_rich")
	tags = ModLoaderUtils.get_array_from_dict(godot_details, "tags")
	config_schema = ModLoaderUtils.get_dict_from_dict(godot_details, "config_schema")
	steam_workshop_id = ModLoaderUtils.get_string_from_dict(godot_details, "steam_workshop_id")

	if ModLoaderStore.ml_options.game_version_validation == ModLoaderOptionsProfile.VERSION_VALIDATION.DEFAULT:
		_is_game_version_compatible(mod_id)

	if ModLoaderStore.ml_options.game_version_validation == ModLoaderOptionsProfile.VERSION_VALIDATION.CUSTOM:
		if ModLoaderStore.ml_options.custom_game_version_validation_callable:
			ModLoaderStore.ml_options.custom_game_version_validation_callable.call(self)
		else:
			ModLoaderLog.error("No custom game version validation callable detected. Please provide a valid validation callable.", LOG_NAME)

	is_mod_id_array_valid(mod_id, dependencies, "dependency")
	is_mod_id_array_valid(mod_id, incompatibilities, "incompatibility")
	is_mod_id_array_valid(mod_id, optional_dependencies, "optional_dependency")
	is_mod_id_array_valid(mod_id, load_before, "load_before")

	validate_distinct_mod_ids_in_arrays(mod_id, dependencies, incompatibilities, ["dependencies", "incompatibilities"])
	validate_distinct_mod_ids_in_arrays(mod_id, optional_dependencies, dependencies, ["optional_dependencies", "dependencies"])
	validate_distinct_mod_ids_in_arrays(mod_id, optional_dependencies, incompatibilities, ["optional_dependencies", "incompatibilities"])
	validate_distinct_mod_ids_in_arrays(
		mod_id,
		load_before,
		dependencies,
		["load_before", "dependencies"],
		"\"load_before\" should be handled as optional dependency adding it to \"dependencies\" will cancel out the desired effect."
	)
	validate_distinct_mod_ids_in_arrays(
		mod_id,
		load_before,
		optional_dependencies,
		["load_before", "optional_dependencies"],
		"\"load_before\" can be viewed as optional dependency, please remove the duplicate mod-id."
	)
	validate_distinct_mod_ids_in_arrays(mod_id,load_before,incompatibilities,["load_before", "incompatibilities"])

	_validate_workshop_id(path)

	return validation_messages_error.is_empty()


# Mod ID used in the mod loader
# Format: {namespace}-{name}
func get_mod_id() -> String:
	return "%s-%s" % [mod_namespace, name]


# Package ID used by Thunderstore
# Format: {namespace}-{name}-{version_number}
func get_package_id() -> String:
	return "%s-%s-%s" % [mod_namespace, name, version_number]


# Returns the Manifest values as a dictionary
func get_as_dict() -> Dictionary:
	return {
		"name": name,
		"namespace": mod_namespace,
		"version_number": version_number,
		"description": description,
		"website_url": website_url,
		"dependencies": dependencies,
		"optional_dependencies": optional_dependencies,
		"authors": authors,
		"compatible_game_version": compatible_game_version,
		"compatible_mod_loader_version": compatible_mod_loader_version,
		"incompatibilities": incompatibilities,
		"load_before": load_before,
		"tags": tags,
		"config_schema": config_schema,
		"description_rich": description_rich,
		"image": image,
	}


# Returns the Manifest values as JSON, in the manifest.json format
func to_json() -> String:
	return JSON.stringify({
		"name": name,
		"namespace": mod_namespace,
		"version_number": version_number,
		"description": description,
		"website_url": website_url,
		"dependencies": dependencies,
		"extra": {
			"godot":{
				"authors": authors,
				"optional_dependencies": optional_dependencies,
				"compatible_game_version": compatible_game_version,
				"compatible_mod_loader_version": compatible_mod_loader_version,
				"incompatibilities": incompatibilities,
				"load_before": load_before,
				"tags": tags,
				"config_schema": config_schema,
				"description_rich": description_rich,
				"image": image,
			}
		}
	}, "\t")


# Loads the default configuration for a mod.
func load_mod_config_defaults() -> ModConfig:
	var default_config_save_path := _ModLoaderPath.get_path_to_mod_config_file(get_mod_id(), ModLoaderConfig.DEFAULT_CONFIG_NAME)
	var config := ModConfig.new(
		get_mod_id(),
		{},
		default_config_save_path,
		config_schema
	)

	# Check if there is no default.json file in the mods config directory
	if not _ModLoaderFile.file_exists(config.save_path):
		# Generate config_default based on the default values in config_schema
		config.data = _generate_default_config_from_schema(config.schema.properties)

	# If the default.json file exists
	else:
		var current_schema_md5 := config.get_schema_as_string().md5_text()
		var cache_schema_md5s := _ModLoaderCache.get_data("config_schemas")
		var cache_schema_md5: String = cache_schema_md5s[config.mod_id] if cache_schema_md5s.has(config.mod_id) else ''

		# Generate a new default config if the config schema has changed or there is nothing cached
		if not current_schema_md5 == cache_schema_md5 or cache_schema_md5.is_empty():
			config.data = _generate_default_config_from_schema(config.schema.properties)

		# If the config schema has not changed just load the json file
		else:
			config.data = _ModLoaderFile.get_json_as_dict(config.save_path)

	# Validate the config defaults
	if config.is_valid():
		# Create the default config file
		config.save_to_file()

		# Store the md5 of the config schema in the cache
		_ModLoaderCache.update_data("config_schemas", {config.mod_id: config.get_schema_as_string().md5_text()} )

		# Return the default ModConfig
		return config

	ModLoaderLog.fatal("The default config values for %s-%s are invalid. Configs will not be loaded." % [mod_namespace, name], LOG_NAME)
	return null


# Recursively searches for default values
func _generate_default_config_from_schema(property: Dictionary, current_prop := {}) -> Dictionary:
	# Exit function if property is empty
	if property.is_empty():
		return current_prop

	for property_key in property.keys():
		var prop = property[property_key]

		# If this property contains nested properties, we recursively call this function
		if "properties" in prop:
			current_prop[property_key] = {}
			_generate_default_config_from_schema(prop.properties, current_prop[property_key])
			# Return early here because a object will not have a "default" key
			return current_prop

		# If this property contains a default value, add it to the global config_defaults dictionary
		if JSONSchema.JSKW_DEFAULT in prop:
			# Initialize the current_key if it is missing in config_defaults
			if not current_prop.has(property_key):
				current_prop[property_key] = {}

			# Add the default value to the config_defaults
			current_prop[property_key] = prop.default

	return current_prop


# Handles deprecation of the single string value in the compatible_mod_loader_version.
func _handle_compatible_mod_loader_version(mod_id: String, godot_details: Dictionary) -> Array:
	var link_manifest_docs := "https://github.com/GodotModding/godot-mod-loader/wiki/Mod-Files#manifestjson"
	var array_value := ModLoaderUtils.get_array_from_dict(godot_details, "compatible_mod_loader_version")

	# If there are array values
	if array_value.size() > 0:
		# Check for valid versions
		if not is_semver_version_array_valid(mod_id, array_value, "compatible_mod_loader_version"):
			return []

		return array_value

	# If the array is empty check if a string was passed
	var string_value := ModLoaderUtils.get_string_from_dict(godot_details, "compatible_mod_loader_version")
	# If an empty string was passed
	if string_value == "":
		# Using str() here because format strings caused an error
		validation_messages_error.push_back(
			str (
				"%s - \"compatible_mod_loader_version\" is a required field." +
				" For more details visit %s"
			) % [mod_id, link_manifest_docs])
		return []

	return [string_value]


# A valid namespace may only use letters (any case), numbers and underscores
# and has to be longer than 3 characters
# a-z A-Z 0-9 _ (longer than 3 characters)
func is_name_or_namespace_valid(check_name: String, is_silent := false) -> bool:
	var re := RegEx.new()
	var _compile_error_1 = re.compile("^[a-zA-Z0-9_]*$") # alphanumeric and _

	if re.search(check_name) == null:
		if not is_silent:
			validation_messages_error.push_back("Invalid name or namespace: \"%s\". You may only use letters, numbers and underscores." % check_name)
		return false

	var _compile_error_2 = re.compile("^[a-zA-Z0-9_]{3,}$") # at least 3 long
	if re.search(check_name) == null:
		if not is_silent:
			validation_messages_error.push_back("Invalid name or namespace: \"%s\". Must be longer than 3 characters." % check_name)
		return false

	return true


func is_semver_version_array_valid(mod_id: String, version_array: PackedStringArray, version_array_descripton: String, is_silent := false) -> bool:
	var is_valid := true

	for version in version_array:
		if not is_semver_valid(mod_id, version, version_array_descripton, is_silent):
			is_valid = false

	return is_valid


# A valid semantic version should follow this format: {mayor}.{minor}.{patch}
# reference https://semver.org/ for details
# {0-9}.{0-9}.{0-9} (no leading 0, shorter than 16 characters total)
func is_semver_valid(mod_id: String, check_version_number: String, field_name: String, is_silent := false) -> bool:
	var re := RegEx.new()
	var _compile_error = re.compile("^(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)\\.(0|[1-9][0-9]*)$")

	if re.search(check_version_number) == null:
		if not is_silent:
			# Using str() here because format strings caused an error
			validation_messages_error.push_back(
				str(
					"Invalid semantic version: \"%s\" in field \"%s\" of mod \"%s\". " +
					"You may only use numbers without leading zero and periods " +
					"following this format {mayor}.{minor}.{patch}"
				)  % [check_version_number, field_name, mod_id]
			)
		return false

	if check_version_number.length() > 16:
		if not is_silent:
			validation_messages_error.push_back(
				str(
					"Invalid semantic version: \"%s\" in field \"%s\" of mod \"%s\". " +
					"Version number must be shorter than 16 characters."
				) % [check_version_number, field_name, mod_id]
			)
		return false

	return true


func validate_distinct_mod_ids_in_arrays(
	mod_id: String,
	array_one: PackedStringArray,
	array_two: PackedStringArray,
	array_description: PackedStringArray,
	additional_info := "",
	is_silent := false
) -> bool:
	# Initialize an empty array to hold any overlaps.
	var overlaps: PackedStringArray = []

	# Loop through each incompatibility and check if it is also listed as a dependency.
	for loop_mod_id in array_one:
		if array_two.has(loop_mod_id):
			overlaps.push_back(loop_mod_id)

	# If no overlaps were found
	if overlaps.size() == 0:
		return true

	# If any overlaps were found
	if not is_silent:
		validation_messages_error.push_back(
			(
				"The mod -> %s lists the same mod(s) -> %s - in \"%s\" and \"%s\". %s"
				% [mod_id, overlaps, array_description[0], array_description[1], additional_info]
			)
		)
		return false

	# If silent just return false
	return false


func is_mod_id_array_valid(own_mod_id: String, mod_id_array: PackedStringArray, mod_id_array_description: String, is_silent := false) -> bool:
	var is_valid := true

	# If there are mod ids
	if mod_id_array.size() > 0:
		for mod_id in mod_id_array:
			# Check if mod id is the same as the mods mod id.
			if mod_id == own_mod_id:
				is_valid = false
				if not is_silent:
					validation_messages_error.push_back("The mod \"%s\" lists itself as \"%s\" in its own manifest.json file" % [mod_id, mod_id_array_description])

			# Check if the mod id is a valid mod id.
			if not is_mod_id_valid(own_mod_id, mod_id, mod_id_array_description, is_silent):
				is_valid = false

	return is_valid


func is_mod_id_valid(original_mod_id: String, check_mod_id: String, type := "", is_silent := false) -> bool:
	var intro_text = "A %s for the mod \"%s\" is invalid: " % [type, original_mod_id] if not type == "" else ""

	# contains hyphen?
	if not check_mod_id.count("-") == 1:
		if not is_silent:
			validation_messages_error.push_back(str(intro_text, "Expected a single hyphen in the mod ID, but the %s was: \"%s\"" % [type, check_mod_id]))
		return false

	# at least 7 long (1 for hyphen, 3 each for namespace/name)
	var mod_id_length = check_mod_id.length()
	if mod_id_length < 7:
		if not is_silent:
			validation_messages_error.push_back(str(intro_text, "Mod ID for \"%s\" is too short. It must be at least 7 characters long, but its length is: %s" % [check_mod_id, mod_id_length]))
		return false

	var split = check_mod_id.split("-")
	var check_namespace = split[0]
	var check_name = split[1]
	var re := RegEx.new()
	re.compile("^[a-zA-Z0-9_]{3,}$") # alphanumeric and _ and at least 3 characters

	if re.search(check_namespace) == null:
		if not is_silent:
			validation_messages_error.push_back(str(intro_text, "Mod ID has an invalid namespace (author) for \"%s\". Namespace can only use letters, numbers and underscores, but was: \"%s\"" % [check_mod_id, check_namespace]))
		return false

	if re.search(check_name) == null:
		if not is_silent:
			validation_messages_error.push_back(str(intro_text, "Mod ID has an invalid name for \"%s\". Name can only use letters, numbers and underscores, but was: \"%s\"" % [check_mod_id, check_name]))
		return false

	return true


func is_string_length_valid(mod_id: String, field: String, string: String, required_length: int, is_silent := false) -> bool:
	if not string.length() == required_length:
		if not is_silent:
			validation_messages_error.push_back("Invalid length in field \"%s\" of mod \"%s\" it should be \"%s\" but it is \"%s\"." % [field, mod_id, required_length, string.length()])
		return false

	return true

# Validates the workshop id separately from the rest since it needs the ModData
func _validate_workshop_id(path: String) -> void:
	var steam_workshop_id_from_path := _ModLoaderPath.get_steam_workshop_id(path)
	var is_mod_source_workshop := not steam_workshop_id_from_path.is_empty()

	if not _is_steam_workshop_id_valid(get_mod_id(), steam_workshop_id_from_path, steam_workshop_id, is_mod_source_workshop):
		# Override the invalid steam_workshop_id if we load from the workshop
		if is_mod_source_workshop:
			steam_workshop_id = steam_workshop_id_from_path


func _is_steam_workshop_id_valid(mod_id: String, steam_workshop_id_from_path: String, steam_workshop_id_to_validate: String, is_mod_source_workshop := false, is_silent := false) -> bool:
	if steam_workshop_id_to_validate.is_empty():
		# Workshop id is optional, so we return true if no id is given
		return true

	# Validate the steam_workshop_id based on the zip_path if the mod is loaded from the workshop
	if is_mod_source_workshop:
		if not steam_workshop_id_to_validate == steam_workshop_id_from_path:
			if not is_silent:
				ModLoaderLog.warning("The \"steam_workshop_id\": \"%s\" provided by the mod manifest of mod \"%s\" is incorrect, it should be \"%s\"." % [steam_workshop_id_to_validate, mod_id, steam_workshop_id_from_path], LOG_NAME)
			return false
	else:
		if not is_string_length_valid(mod_id, "steam_workshop_id", steam_workshop_id_to_validate, 10, is_silent):
			# Invalidate the manifest in this case because the mod is most likely in development if it is not loaded from the steam workshop.
			return false

	return true


func _is_game_version_compatible(mod_id: String) -> bool:
	var game_version: String = ModLoaderStore.ml_options.semantic_version
	var game_major := int(game_version.get_slice(".", 0))
	var game_minor := int(game_version.get_slice(".", 1))

	var valid_major := false
	var valid_minor := false
	for version in compatible_game_version:
		var compat_major := int(version.get_slice(".", 0))
		var compat_minor := int(version.get_slice(".", 1))
		if compat_major < game_major:
			continue
		valid_major = true

		if compat_minor < game_minor:
			continue
		valid_minor = true

	if not valid_major:
		validation_messages_error.push_back(
			"The mod \"%s\" is incompatible with the current game version.
			(current game version: %s, mod compatible with game versions: %s)" %
			[mod_id, game_version, compatible_game_version]
		)
		return false
	if not valid_minor:
		validation_messages_warning.push_back(
			"The mod \"%s\" may not be compatible with the current game version.
			Enable at your own risk. (current game version: %s, mod compatible with game versions: %s)" %
			[mod_id, game_version, compatible_game_version]
		)
		return true

	return true