tool
extends SceneTree

signal updated(plugin)

const VERSION = "0.1.1"
const DEFAULT_PLUGIN_URL = "https://git::@github.com/%s.git"
const DEFAULT_PLUG_DIR = "res://.plugged"
const DEFAULT_CONFIG_PATH = DEFAULT_PLUG_DIR + "/index.cfg"
const DEFAULT_USER_PLUG_SCRIPT_PATH = "res://plug.gd"
const DEFAULT_BASE_PLUG_SCRIPT_PATH = "res://addons/gd-plug/plug.gd"

const ENV_PRODUCTION = "production"
const ENV_TEST = "test"
const ENV_FORCE = "force"
const ENV_KEEP_IMPORT_FILE = "keep_import_file"
const ENV_KEEP_IMPORT_RESOURCE_FILE = "keep_import_resource_file"

const MSG_PLUG_START_ASSERTION = "_plug_start() must be called first"

var project_dir = Directory.new()
var installation_config = ConfigFile.new()
var logger = _Logger.new()

var _installed_plugins
var _plugged_plugins = {}

var _threads = []
var _mutex = Mutex.new()
var _start_time = 0
var threadpool = _ThreadPool.new(logger)


func _init():
	threadpool.connect("all_thread_finished", self, "request_quit")


func _initialize():
	var args = OS.get_cmdline_args()
	# Trim unwanted args passed to godot executable
	for arg in Array(args):
		args.remove(0)
		if "plug.gd" in arg:
			break

	for arg in args:
		# NOTE: "--key" or "-key" will always be consumed by godot executable, see https://github.com/godotengine/godot/issues/8721
		var key = arg.to_lower()
		match key:
			"detail":
				logger.log_format = _Logger.DEFAULT_LOG_FORMAT_DETAIL
			"debug", "d":
				logger.log_level = _Logger.LogLevel.DEBUG
			"quiet", "q", "silent":
				logger.log_level = _Logger.LogLevel.NONE
			"production":
				OS.set_environment(ENV_PRODUCTION, "true")
			"test":
				OS.set_environment(ENV_TEST, "true")
			"force":
				OS.set_environment(ENV_FORCE, "true")
			"keep-import-file":
				OS.set_environment(ENV_KEEP_IMPORT_FILE, "true")
			"keep-import-resource-file":
				OS.set_environment(ENV_KEEP_IMPORT_RESOURCE_FILE, "true")

	logger.debug("cmdline_args: %s" % args)
	_start_time = OS.get_system_time_msecs()
	_plug_start()
	if args.size() > 0:
		_plugging()
		match args[0]:
			"init":
				_plug_init()
			"install", "update":
				_plug_install()
			"uninstall":
				_plug_uninstall()
			"clean":
				_plug_clean()
			"upgrade":
				_plug_upgrade()
			"status":
				_plug_status()
			"version":
				logger.info(VERSION)
			_:
				logger.error("Unknown command %s" % args[0])
	# NOTE: Do no put anything after this line except request_quit(), as _plug_*() may call request_quit()
	request_quit()


func _idle(delta):
	threadpool.process(delta)


func _finalize():
	_plug_end()
	logger.info("Finished, elapsed %.3fs" % ((OS.get_system_time_msecs() - _start_time) / 1000.0))


func _on_updated(plugin):
	pass


func _plugging():
	pass


func request_quit(exit_code = -1):
	if threadpool.is_all_thread_finished() and threadpool.is_all_task_finished():
		quit(exit_code)
		return true
	logger.debug("Request quit declined, threadpool is still running")
	return false


# Index installed plugins, or create directory "plugged" if not exists
func _plug_start():
	logger.debug("Plug start")
	if not project_dir.dir_exists(DEFAULT_PLUG_DIR):
		if project_dir.make_dir(ProjectSettings.globalize_path(DEFAULT_PLUG_DIR)) == OK:
			logger.debug("Make dir %s for plugin installation")
	if installation_config.load(DEFAULT_CONFIG_PATH) == OK:
		logger.debug("Installation config loaded")
	else:
		logger.debug("Installation config not found")
	_installed_plugins = installation_config.get_value("plugin", "installed", {})


# Install plugin or uninstall plugin if unlisted
func _plug_end():
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	var test = !!OS.get_environment(ENV_TEST)
	if not test:
		installation_config.set_value("plugin", "installed", _installed_plugins)
		if installation_config.save(DEFAULT_CONFIG_PATH) == OK:
			logger.debug("Plugged config saved")
		else:
			logger.error("Failed to save plugged config")
	else:
		logger.warn("Skipped saving of plugged config in test mode")
	_installed_plugins = null


func _plug_init():
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	logger.info("Init gd-plug...")
	var file = File.new()
	if file.file_exists(DEFAULT_USER_PLUG_SCRIPT_PATH):
		logger.warn("%s already exists!" % DEFAULT_USER_PLUG_SCRIPT_PATH)
	else:
		file.open(DEFAULT_USER_PLUG_SCRIPT_PATH, File.WRITE)
		file.store_string(INIT_PLUG_SCRIPT)
		file.close()
		logger.info("Created %s" % DEFAULT_USER_PLUG_SCRIPT_PATH)


func _plug_install():
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	logger.info("Installing...")
	for plugin in _plugged_plugins.values():
		var installed = plugin.name in _installed_plugins
		if installed:
			var installed_plugin = get_installed_plugin(plugin.name)
			if (installed_plugin.dev or plugin.dev) and OS.get_environment(ENV_PRODUCTION):
				logger.info("Remove dev plugin for production: %s" % plugin.name)
				threadpool.enqueue_task(self, "uninstall_plugin", installed_plugin)
			else:
				threadpool.enqueue_task(self, "update_plugin", plugin)
		else:
			threadpool.enqueue_task(self, "install_plugin", plugin)

	var removed_plugins = []
	for plugin in _installed_plugins.values():
		var removed = not (plugin.name in _plugged_plugins)
		if removed:
			removed_plugins.append(plugin)
	if removed_plugins:
		threadpool.disconnect("all_thread_finished", self, "request_quit")
		if not threadpool.is_all_thread_finished():
			yield(threadpool, "all_thread_finished")
			logger.debug("All installation finished! Ready to uninstall removed plugins...")
		threadpool.connect("all_thread_finished", self, "request_quit")
		for plugin in removed_plugins:
			threadpool.enqueue_task(self, "uninstall_plugin", plugin, Thread.PRIORITY_LOW)


func _plug_uninstall():
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	logger.info("Uninstalling...")
	for plugin in _installed_plugins.values():
		var installed_plugin = get_installed_plugin(plugin.name)
		threadpool.enqueue_task(self, "uninstall_plugin", installed_plugin, Thread.PRIORITY_LOW)


func _plug_clean():
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	logger.info("Cleaning...")
	var plugged_dir = Directory.new()
	plugged_dir.open(DEFAULT_PLUG_DIR)
	plugged_dir.list_dir_begin(true, true)
	var file = plugged_dir.get_next()
	while not file.empty():
		if plugged_dir.current_is_dir():
			if not (file in _installed_plugins):
				logger.info("Remove %s" % file)
				threadpool.enqueue_task(
					self, "directory_delete_recursively", plugged_dir.get_current_dir() + "/" + file
				)
		file = plugged_dir.get_next()
	plugged_dir.list_dir_end()


func _plug_upgrade():
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	logger.info("Upgrading gd-plug...")
	plug("imjp94/gd-plug")
	var gd_plug = _plugged_plugins["gd-plug"]
	OS.set_environment(ENV_FORCE, "true")  # Required to overwrite res://addons/gd-plug/plug.gd
	threadpool.enqueue_task(self, "install_plugin", gd_plug)
	threadpool.disconnect("all_thread_finished", self, "request_quit")
	if not threadpool.is_all_thread_finished():
		yield(threadpool, "all_thread_finished")
		logger.debug("All installation finished! Ready to uninstall removed plugins...")
	threadpool.connect("all_thread_finished", self, "request_quit")
	threadpool.enqueue_task(self, "directory_delete_recursively", gd_plug.plug_dir)


func _plug_status():
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	logger.info(
		(
			"Installed %d plugin%s"
			% [_installed_plugins.size(), "s" if _installed_plugins.size() > 1 else ""]
		)
	)
	var new_plugins = _plugged_plugins.duplicate()
	var has_checking_plugin = false
	var removed_plugins = []
	for plugin in _installed_plugins.values():
		logger.info("- {name} - {url}".format(plugin))
		new_plugins.erase(plugin.name)
		var removed = not (plugin.name in _plugged_plugins)
		if removed:
			removed_plugins.append(plugin)
		else:
			threadpool.enqueue_task(self, "check_plugin", _plugged_plugins[plugin.name])
			has_checking_plugin = true
	if has_checking_plugin:
		logger.info("\n", true)
		threadpool.disconnect("all_thread_finished", self, "request_quit")
		yield(threadpool, "all_thread_finished")
		threadpool.connect("all_thread_finished", self, "request_quit")
		logger.debug("Finished checking plugins, ready to proceed")
	if new_plugins:
		logger.info(
			"\nPlugged %d plugin%s" % [new_plugins.size(), "s" if new_plugins.size() > 1 else ""]
		)
		for plugin in new_plugins.values():
			var is_new = not (plugin.name in _installed_plugins)
			if is_new:
				logger.info("- {name} - {url}".format(plugin))
	if removed_plugins:
		logger.info(
			(
				"\nUnplugged %d plugin%s"
				% [removed_plugins.size(), "s" if removed_plugins.size() > 1 else ""]
			)
		)
		for plugin in removed_plugins:
			logger.info("- %s removed" % plugin.name)
	var plug_directory = Directory.new()
	var orphan_dirs = []
	if plug_directory.open(DEFAULT_PLUG_DIR) == OK:
		plug_directory.list_dir_begin(true, true)
		var file = plug_directory.get_next()
		while not file.empty():
			if plug_directory.current_is_dir():
				if not (file in _installed_plugins):
					orphan_dirs.append(file)
			file = plug_directory.get_next()
		plug_directory.list_dir_end()
	if orphan_dirs:
		logger.info(
			(
				'\nOrphan directory, %d found in %s, execute "clean" command to remove'
				% [orphan_dirs.size(), DEFAULT_PLUG_DIR]
			)
		)
		for dir in orphan_dirs:
			logger.info("- %s" % dir)

	if has_checking_plugin:
		request_quit()


# Index & validate plugin
func plug(repo, args = {}):
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	repo = repo.strip_edges()
	var plugin_name = get_plugin_name_from_repo(repo)
	if plugin_name in _plugged_plugins:
		logger.info("Plugin already plugged: %s" % plugin_name)
		return
	var plugin = {}
	plugin.name = plugin_name
	plugin.url = ""
	if ":" in repo:
		plugin.url = repo
	elif repo.find("/") == repo.rfind("/"):
		plugin.url = DEFAULT_PLUGIN_URL % repo
	else:
		logger.error("Invalid repo: %s" % repo)
	plugin.plug_dir = DEFAULT_PLUG_DIR + "/" + plugin.name

	var is_valid = true
	plugin.include = args.get("include", [])
	is_valid = is_valid and validate_var_type(plugin, "include", TYPE_ARRAY, "Array")
	plugin.exclude = args.get("exclude", [])
	is_valid = is_valid and validate_var_type(plugin, "exclude", TYPE_ARRAY, "Array")
	plugin.branch = args.get("branch", "")
	is_valid = is_valid and validate_var_type(plugin, "branch", TYPE_STRING, "String")
	plugin.tag = args.get("tag", "")
	is_valid = is_valid and validate_var_type(plugin, "tag", TYPE_STRING, "String")
	plugin.commit = args.get("commit", "")
	is_valid = is_valid and validate_var_type(plugin, "commit", TYPE_STRING, "String")
	if not plugin.commit.empty():
		var is_valid_commit = plugin.commit.length() == 40
		if not is_valid_commit:
			logger.error(
				"Expected full length 40 digits commit-hash string, given %s" % plugin.commit
			)
		is_valid = is_valid and is_valid_commit
	plugin.dev = args.get("dev", false)
	is_valid = is_valid and validate_var_type(plugin, "dev", TYPE_BOOL, "Boolean")
	plugin.on_updated = args.get("on_updated", "")
	is_valid = is_valid and validate_var_type(plugin, "on_updated", TYPE_STRING, "String")
	plugin.install_root = args.get("install_root", "")
	is_valid = is_valid and validate_var_type(plugin, "install_root", TYPE_STRING, "String")

	if is_valid:
		_plugged_plugins[plugin.name] = plugin
		logger.debug("Plug: %s" % plugin)
	else:
		logger.error("Failed to plug %s, validation error" % plugin.name)


func install_plugin(plugin):
	var test = !!OS.get_environment(ENV_TEST)
	var can_install = not OS.get_environment(ENV_PRODUCTION) if plugin.dev else true
	if can_install:
		logger.info("Installing plugin %s..." % plugin.name)
		var result = is_plugin_downloaded(plugin)
		if result != OK:
			result = downlaod(plugin)
		else:
			logger.info("Plugin already downloaded")

		if result == OK:
			install(plugin)
		else:
			logger.error("Failed to install plugin %s with error code %d" % [plugin.name, result])


func uninstall_plugin(plugin):
	var test = !!OS.get_environment(ENV_TEST)
	logger.info("Uninstalling plugin %s..." % plugin.name)
	uninstall(plugin)
	directory_delete_recursively(plugin.plug_dir, {"exclude": [DEFAULT_CONFIG_PATH], "test": test})


func update_plugin(plugin, checking = false):
	if not (plugin.name in _installed_plugins):
		logger.info("%s new plugin" % plugin.name)
		return true

	var git = _GitExecutable.new(ProjectSettings.globalize_path(plugin.plug_dir), logger)
	var installed_plugin = get_installed_plugin(plugin.name)
	var changes = compare_plugins(plugin, installed_plugin)
	var should_clone = false
	var should_pull = false
	var should_reinstall = false

	if plugin.tag or plugin.commit:
		for rev in ["tag", "commit"]:
			var freeze_at = plugin[rev]
			if freeze_at:
				logger.info('%s frozen at %s "%s"' % [plugin.name, rev, freeze_at])
				break
	else:
		var ahead_behind = []
		if git.fetch("origin " + plugin.branch if plugin.branch else "origin").exit == OK:
			ahead_behind = git.get_commit_comparison(
				"HEAD", "origin/" + plugin.branch if plugin.branch else "origin"
			)
		var is_commit_behind = !!ahead_behind[1] if ahead_behind.size() == 2 else false
		if is_commit_behind:
			logger.info("%s %d commits behind, update required" % [plugin.name, ahead_behind[1]])
			should_pull = true
		else:
			logger.info("%s up to date" % plugin.name)

	if changes:
		logger.info("%s changed %s" % [plugin.name, changes])
		should_reinstall = true
		if "url" in changes or "branch" in changes or "tag" in changes or "commit" in changes:
			logger.info("%s repository setting changed, update required" % plugin.name)
			should_clone = true

	if not checking:
		if should_clone:
			logger.info("%s cloning from %s..." % [plugin.name, plugin.url])
			var test = !!OS.get_environment(ENV_TEST)
			uninstall(get_installed_plugin(plugin.name))
			directory_delete_recursively(
				plugin.plug_dir, {"exclude": [DEFAULT_CONFIG_PATH], "test": test}
			)
			if downlaod(plugin) == OK:
				install(plugin)
		elif should_pull:
			logger.info("%s pulling updates from %s..." % [plugin.name, plugin.url])
			uninstall(get_installed_plugin(plugin.name))
			if git.pull().exit == OK:
				install(plugin)
		elif should_reinstall:
			logger.info("%s reinstalling..." % plugin.name)
			uninstall(get_installed_plugin(plugin.name))
			install(plugin)


func check_plugin(plugin):
	update_plugin(plugin, true)


func downlaod(plugin):
	logger.info("Downloading %s from %s..." % [plugin.name, plugin.url])
	var test = !!OS.get_environment(ENV_TEST)
	var global_dest_dir = ProjectSettings.globalize_path(plugin.plug_dir)
	if project_dir.dir_exists(plugin.plug_dir):
		directory_delete_recursively(plugin.plug_dir)
	project_dir.make_dir(plugin.plug_dir)
	var result = _GitExecutable.new(global_dest_dir, logger).clone(
		plugin.url,
		global_dest_dir,
		{"branch": plugin.branch, "tag": plugin.tag, "commit": plugin.commit}
	)
	if result.exit == OK:
		logger.info("Successfully download %s" % [plugin.name])
	else:
		logger.info("Failed to download %s" % plugin.name)
		# Make sure plug_dir is clean when failed
		directory_delete_recursively(
			plugin.plug_dir, {"exclude": [DEFAULT_CONFIG_PATH], "test": test}
		)
	project_dir.remove(plugin.plug_dir)  # Remove empty directory
	return result.exit


func install(plugin):
	var include = plugin.get("include", [])
	if include.empty():  # Auto include "addons/" folder if not explicitly specified
		include = ["addons/"]
	if not OS.get_environment(ENV_FORCE) and not OS.get_environment(ENV_TEST):
		var is_exists = false
		var dest_files = directory_copy_recursively(
			plugin.plug_dir,
			"res://" + plugin.install_root,
			{"include": include, "exclude": plugin.exclude, "test": true, "silent_test": true}
		)
		for dest_file in dest_files:
			if project_dir.file_exists(dest_file):
				logger.warn("%s attempting to overwrite file %s" % [plugin.name, dest_file])
				is_exists = true
		if is_exists:
			logger.warn(
				(
					'Installation of %s terminated to avoid overwriting user files, you may disable safe mode with command "force"'
					% plugin.name
				)
			)
			return ERR_ALREADY_EXISTS

	logger.info("Installing files for %s..." % plugin.name)
	var test = !!OS.get_environment(ENV_TEST)
	var dest_files = directory_copy_recursively(
		plugin.plug_dir,
		"res://" + plugin.install_root,
		{"include": include, "exclude": plugin.exclude, "test": test}
	)
	plugin.dest_files = dest_files
	logger.info(
		(
			"Installed %d file%s for %s"
			% [dest_files.size(), "s" if dest_files.size() > 1 else "", plugin.name]
		)
	)
	if plugin.name != "gd-plug":
		set_installed_plugin(plugin)
	if plugin.on_updated:
		if has_method(plugin.on_updated):
			logger.info("Execute post-update function for %s: %s" % [plugin.name, plugin.do])
			_on_updated(plugin)
			call(plugin.on_updated, plugin.duplicate())
			emit_signal("updated", plugin)
	return OK


func uninstall(plugin):
	var test = !!OS.get_environment(ENV_TEST)
	var keep_import_file = !!OS.get_environment(ENV_KEEP_IMPORT_FILE)
	var keep_import_resource_file = !!OS.get_environment(ENV_KEEP_IMPORT_RESOURCE_FILE)
	var dest_files = plugin.get("dest_files", [])
	logger.info(
		(
			"Uninstalling %d file%s for %s..."
			% [dest_files.size(), "s" if dest_files.size() > 1 else "", plugin.name]
		)
	)
	directory_remove_batch(
		dest_files,
		{
			"test": test,
			"keep_import_file": keep_import_file,
			"keep_import_resource_file": keep_import_resource_file
		}
	)
	logger.info(
		(
			"Uninstalled %d file%s for %s"
			% [dest_files.size(), "s" if dest_files.size() > 1 else "", plugin.name]
		)
	)
	remove_installed_plugin(plugin.name)


func is_plugin_downloaded(plugin):
	if not project_dir.dir_exists(plugin.plug_dir + "/.git"):
		return

	var git = _GitExecutable.new(ProjectSettings.globalize_path(plugin.plug_dir), logger)
	return git.is_up_to_date(plugin)


# Get installed plugin, thread safe
func get_installed_plugin(plugin_name):
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	_mutex.lock()
	var installed_plugin = _installed_plugins[plugin_name]
	_mutex.unlock()
	return installed_plugin


# Set installed plugin, thread safe
func set_installed_plugin(plugin):
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	_mutex.lock()
	_installed_plugins[plugin.name] = plugin
	_mutex.unlock()


# Remove installed plugin, thread safe
func remove_installed_plugin(plugin_name):
	assert(_installed_plugins != null, MSG_PLUG_START_ASSERTION)
	_mutex.lock()
	var result = _installed_plugins.erase(plugin_name)
	_mutex.unlock()
	return result


func directory_copy_recursively(from, to, args = {}):
	var include = args.get("include", [])
	var exclude = args.get("exclude", [])
	var test = args.get("test", false)
	var silent_test = args.get("silent_test", false)
	var dir = Directory.new()
	var dest_files = []
	if dir.open(from) == OK:
		dir.list_dir_begin(true, true)
		var file_name = dir.get_next()
		while not file_name.empty():
			var source = (
				dir.get_current_dir()
				+ ("/" if dir.get_current_dir() != "res://" else "")
				+ file_name
			)
			var dest = to + ("/" if to != "res://" else "") + file_name

			if dir.current_is_dir():
				dest_files += directory_copy_recursively(source, dest, args)
			else:
				for include_key in include:
					if include_key in source:
						var is_excluded = false
						for exclude_key in exclude:
							if exclude_key in source:
								is_excluded = true
								break
						if not is_excluded:
							if test:
								if not silent_test:
									logger.warn("[TEST] Writing to %s" % dest)
							else:
								dir.make_dir_recursive(to)
								if dir.copy(source, dest) == OK:
									logger.debug("Copy from %s to %s" % [source, dest])
							dest_files.append(dest)
						break
			file_name = dir.get_next()
		dir.list_dir_end()
	else:
		logger.error("Failed to access path: %s" % from)

	return dest_files


func directory_delete_recursively(dir_path, args = {}):
	var remove_empty_directory = args.get("remove_empty_directory", true)
	var exclude = args.get("exclude", [])
	var test = args.get("test", false)
	var silent_test = args.get("silent_test", false)
	var dir = Directory.new()
	if dir.open(dir_path) == OK:
		dir.list_dir_begin(true, false)
		var file_name = dir.get_next()
		while not file_name.empty():
			var source = (
				dir.get_current_dir()
				+ ("/" if dir.get_current_dir() != "res://" else "")
				+ file_name
			)

			if dir.current_is_dir():
				var sub_dir = directory_delete_recursively(source, args)
				if remove_empty_directory:
					if test:
						if not silent_test:
							logger.warn(
								"[TEST] Remove empty directory: %s" % sub_dir.get_current_dir()
							)
					else:
						if source.get_file() == ".git":
							# Hacks to remove .git, as git pack files stop it from being removed
							# See https://stackoverflow.com/questions/1213430/how-to-fully-delete-a-git-repository-created-with-init
							if (
								OS.execute("rm", ["-rf", ProjectSettings.globalize_path(source)])
								== OK
							):
								logger.debug(
									"Remove empty directory: %s" % sub_dir.get_current_dir()
								)
						else:
							if dir.remove(sub_dir.get_current_dir()) == OK:
								logger.debug(
									"Remove empty directory: %s" % sub_dir.get_current_dir()
								)
			else:
				var excluded = false
				for exclude_key in exclude:
					if source in exclude_key:
						excluded = true
						break
				if not excluded:
					if test:
						if not silent_test:
							logger.warn("[TEST] Remove file: %s" % source)
					else:
						if dir.remove(file_name) == OK:
							logger.debug("Remove file: %s" % source)
			file_name = dir.get_next()
		dir.list_dir_end()
	else:
		logger.error("Failed to access path: %s" % dir_path)

	if remove_empty_directory:
		dir.remove(dir.get_current_dir())

	return dir


func directory_remove_batch(files, args = {}):
	var remove_empty_directory = args.get("remove_empty_directory", true)
	var keep_import_file = args.get("keep_import_file", false)
	var keep_import_resource_file = args.get("keep_import_resource_file", false)
	var test = args.get("test", false)
	var silent_test = args.get("silent_test", false)
	var dirs = {}
	for file in files:
		var file_dir = file.get_base_dir()
		var file_name = file.get_file()
		var dir = dirs.get(file_dir)

		if not dir:
			dir = Directory.new()
			dir.open(file_dir)
			dirs[file_dir] = dir

		if file.ends_with(".import"):
			if not keep_import_file:
				_remove_import_file(dir, file, keep_import_resource_file, test, silent_test)
		else:
			if test:
				if not silent_test:
					logger.warn("[TEST] Remove file: " + file)
			else:
				if dir.remove(file_name) == OK:
					logger.debug("Remove file: " + file)
			if not keep_import_file:
				_remove_import_file(
					dir, file + ".import", keep_import_resource_file, test, silent_test
				)

	for dir in dirs.values():
		var slash_count = dir.get_current_dir().count("/") - 2  # Deduct 2 slash from "res://"
		if test:
			if not silent_test:
				logger.warn("[TEST] Remove empty directory: %s" % dir.get_current_dir())
		else:
			if dir.remove(dir.get_current_dir()) == OK:
				logger.debug("Remove empty directory: %s" % dir.get_current_dir())
		# Dumb method to clean empty ancestor directories
		logger.debug("Removing emoty ancestor directory for %s..." % dir.get_current_dir())
		var current_dir = dir.get_current_dir()
		for i in slash_count:
			current_dir = current_dir.get_base_dir()
			var d = Directory.new()
			if d.open(current_dir) == OK:
				if test:
					if not silent_test:
						logger.warn(
							"[TEST] Remove empty ancestor directory: %s" % d.get_current_dir()
						)
				else:
					if d.remove(d.get_current_dir()) == OK:
						logger.debug("Remove empty ancestor directory: %s" % d.get_current_dir())


func _remove_import_file(
	dir, file, keep_import_resource_file = false, test = false, silent_test = false
):
	if not dir.file_exists(file):
		return

	if not keep_import_resource_file:
		var import_config = ConfigFile.new()
		if import_config.load(file) == OK:
			var metadata = import_config.get_value("remap", "metadata", {})
			var imported_formats = metadata.get("imported_formats", [])
			if imported_formats:
				for format in imported_formats:
					_remove_import_resource_file(dir, import_config, "." + format, test)
			else:
				_remove_import_resource_file(dir, import_config, "", test)
	if test:
		if not silent_test:
			logger.warn("[TEST] Remove import file: " + file)
	else:
		if dir.remove(file) == OK:
			logger.debug("Remove import file: " + file)
		else:
			# TODO: Sometimes Directory.remove() unable to remove random .import file and return error code 1(Generic Error)
			# Maybe enforce the removal from shell?
			logger.warn("Failed to remove import file: " + file)


func _remove_import_resource_file(dir, import_config, import_format = "", test = false):
	var import_resource_file = import_config.get_value("remap", "path" + import_format, "")
	var checksum_file = (
		import_resource_file.trim_suffix("." + import_resource_file.get_extension()) + ".md5"
		if import_resource_file
		else ""
	)
	if import_resource_file:
		if dir.file_exists(import_resource_file):
			if test:
				logger.info("[IMPORT] Remove import resource file: " + import_resource_file)
			else:
				if dir.remove(import_resource_file) == OK:
					logger.debug("Remove import resource file: " + import_resource_file)
	if checksum_file:
		checksum_file = checksum_file.replace(import_format, "")
		if dir.file_exists(checksum_file):
			if test:
				logger.info("[IMPORT] Remove import checksum file: " + checksum_file)
			else:
				if dir.remove(checksum_file) == OK:
					logger.debug("Remove import checksum file: " + checksum_file)


func compare_plugins(p1, p2):
	var changed_keys = []
	for key in p1.keys():
		var v1 = p1[key]
		var v2 = p2[key]
		if v1 != v2:
			changed_keys.append(key)
	return changed_keys


func get_plugin_name_from_repo(repo):
	repo = repo.replace(".git", "").trim_suffix("/")
	return repo.get_file()


func validate_var_type(obj, var_name, type, type_string):
	var value = obj.get(var_name)
	var is_valid = typeof(value) == type
	if not is_valid:
		logger.error('Expected variable "%s" to be %s, given %s' % [var_name, type_string, value])
	return is_valid


const INIT_PLUG_SCRIPT = """extends "res://addons/gd-plug/plug.gd"

func _plugging():
	# Declare plugins with plug(repo, args)
	# For example, clone from github repo("user/repo_name")
	# plug("imjp94/gd-YAFSM") # By default, gd-plug will only install anything from "addons/" directory
	# Or you can explicitly specify which file/directory to include
	# plug("imjp94/gd-YAFSM", {"include": ["addons/"]}) # By default, gd-plug will only install anything from "addons/" directory
	pass
"""


class _GitExecutable:
	extends Reference
	var cwd = ""
	var logger

	func _init(p_cwd, p_logger):
		cwd = p_cwd
		logger = p_logger

	func _execute(command, blocking = true, output = [], read_stderr = false):
		var cmd = "cd %s && %s" % [cwd, command]
		# NOTE: OS.execute() seems to ignore read_stderr
		var exit = FAILED
		match OS.get_name():
			"Windows":
				cmd = cmd if read_stderr else "%s 2> nul" % cmd
				logger.debug('Execute "%s"' % cmd)
				exit = OS.execute("cmd", ["/C", cmd], blocking, output, read_stderr)
			"X11", "OSX", "Server":
				cmd if read_stderr else "%s 2>/dev/null" % cmd
				logger.debug('Execute "%s"' % cmd)
				exit = OS.execute("bash", ["-c", cmd], blocking, output, read_stderr)
			var unhandled_os:
				logger.error("Unexpected OS: %s" % unhandled_os)
		logger.debug("Execution ended(code:%d): %s" % [exit, output])
		return exit

	func init():
		logger.debug("Initializing git at %s..." % cwd)
		var output = []
		var exit = _execute("git init", true, output)
		logger.debug("Successfully init" if exit == OK else "Failed to init")
		return {"exit": exit, "output": output}

	func clone(src, dest, args = {}):
		logger.debug("Cloning from %s to %s..." % [src, dest])
		var output = []
		var branch = args.get("branch", "")
		var tag = args.get("tag", "")
		var commit = args.get("commit", "")
		var command = "git clone --depth=1 --progress %s %s" % [src, dest]
		if branch or tag:
			command = (
				"git clone --depth=1 --single-branch --branch %s %s %s"
				% [branch if branch else tag, src, dest]
			)
		elif commit:
			return clone_commit(src, dest, commit)
		var exit = _execute(command, true, output)
		logger.debug(
			"Successfully cloned from %s" % src if exit == OK else "Failed to clone from %s" % src
		)
		return {"exit": exit, "output": output}

	func clone_commit(src, dest, commit):
		var output = []
		if commit.length() < 40:
			logger.error(
				(
					"Expected full length 40 digits commit-hash to clone specific commit, given {%s}"
					% commit
				)
			)
			return {"exit": FAILED, "output": output}

		logger.debug("Cloning from %s to %s @ %s..." % [src, dest, commit])
		var result = init()
		if result.exit == OK:
			result = remote_add("origin", src)
			if result.exit == OK:
				result = fetch("%s %s" % ["origin", commit])
				if result.exit == OK:
					result = reset("--hard", "FETCH_HEAD")
		return result

	func fetch(rm = "--all"):
		logger.debug("Fetching %s..." % rm.replace("--", ""))
		var output = []
		var exit = _execute("git fetch %s" % rm, true, output)
		logger.debug("Successfully fetched" if exit == OK else "Failed to fetch")
		return {"exit": exit, "output": output}

	func pull():
		logger.debug("Pulling...")
		var output = []
		var exit = _execute("git pull --rebase", true, output)
		logger.debug("Successfully pulled" if exit == OK else "Failed to pull")
		return {"exit": exit, "output": output}

	func remote_add(name, src):
		logger.debug("Adding remote %s@%s..." % [name, src])
		var output = []
		var exit = _execute("git remote add %s %s" % [name, src], true, output)
		logger.debug("Successfully added remote" if exit == OK else "Failed to add remote")
		return {"exit": exit, "output": output}

	func reset(mode, to):
		logger.debug("Resetting %s %s..." % [mode, to])
		var output = []
		var exit = _execute("git reset %s %s" % [mode, to], true, output)
		logger.debug("Successfully reset" if exit == OK else "Failed to reset")
		return {"exit": exit, "output": output}

	func get_commit_comparison(branch_a, branch_b):
		var output = []
		var exit = _execute(
			"git rev-list --count --left-right %s...%s" % [branch_a, branch_b], true, output
		)
		var raw_ahead_behind = output[0].split("\t")
		var ahead_behind = []
		for msg in raw_ahead_behind:
			ahead_behind.append(int(msg))
		return ahead_behind if exit == OK else []

	func get_current_branch():
		var output = []
		var exit = _execute("git rev-parse --abbrev-ref HEAD", true, output)
		return output[0] if exit == OK else ""

	func get_current_tag():
		var output = []
		var exit = _execute("git describe --tags --exact-match", true, output)
		return output[0] if exit == OK else ""

	func get_current_commit():
		var output = []
		var exit = _execute("git rev-parse --short HEAD", true, output)
		return output[0] if exit == OK else ""

	func is_detached_head():
		var output = []
		var exit = _execute("git rev-parse --short HEAD", true, output)
		return (!!output[0]) if exit == OK else true

	func is_up_to_date(args = {}):
		if fetch().exit == OK:
			var branch = args.get("branch", "")
			var tag = args.get("tag", "")
			var commit = args.get("commit", "")

			if branch:
				if branch == get_current_branch():
					return FAILED if is_detached_head() else OK
			elif tag:
				if tag == get_current_tag():
					return OK
			elif commit:
				if commit == get_current_commit():
					return OK

			var ahead_behind = get_commit_comparison("HEAD", "origin")
			var is_commit_behind = !!ahead_behind[1] if ahead_behind.size() == 2 else false
			return FAILED if is_commit_behind else OK
		return FAILED


class _ThreadPool:
	extends Reference
	signal all_thread_finished

	var _threads = []
	var _finished_threads = []
	var _mutex = Mutex.new()
	var _tasks = []
	var logger

	func _init(p_logger):
		logger = p_logger
		_threads.resize(OS.get_processor_count())

	func _execute_task(task):
		var thread = _get_thread()
		var can_execute = thread
		if can_execute:
			task.thread = weakref(thread)
			thread.start(self, "_execute", task, task.priority)
			logger.debug("Execute task %s.%s() " % [task.instance, task.method])
		return can_execute

	func _execute(args):
		args.instance.call(args.method, args.userdata)
		_mutex.lock()
		var thread = args.thread.get_ref()
		_threads[_threads.find(thread)] = null
		_finished_threads.append(thread)
		var all_finished = is_all_thread_finished()
		_mutex.unlock()

		logger.debug("Execution finished %s.%s() " % [args.instance, args.method])
		if all_finished:
			logger.debug("All thread finished")
			emit_signal("all_thread_finished")

	func _flush_tasks():
		if not _tasks:
			return

		var executed = true
		while executed:
			var task = _tasks.pop_front()
			if task != null:
				executed = _execute_task(task)
				if not executed:
					_tasks.push_front(task)
			else:
				executed = false

	func _flush_threads():
		for i in _finished_threads.size():
			var thread = _finished_threads.pop_front()
			thread.wait_to_finish()

	func enqueue_task(instance, method, userdata = null, priority = 1):
		enqueue(
			{"instance": instance, "method": method, "userdata": userdata, "priority": priority}
		)

	func enqueue(task):
		var can_execute = _execute_task(task)
		if not can_execute:
			_tasks.append(task)

	func process(delta):
		_flush_tasks()
		_flush_threads()

	func _get_thread():
		var thread
		for i in OS.get_processor_count():
			var t = _threads[i]
			if t:
				if not t.is_active():
					thread = t
					break
			else:
				thread = Thread.new()
				_threads[i] = thread
				break
		return thread

	func is_all_thread_finished():
		for i in _threads.size():
			if _threads[i]:
				return false
		return true

	func is_all_task_finished():
		for i in _tasks.size():
			if _tasks[i]:
				return false
		return true


class _Logger:
	extends Reference
	enum LogLevel { ALL, DEBUG, INFO, WARN, ERROR, NONE }
	const DEFAULT_LOG_FORMAT_DETAIL = "[{time}] [{level}] {msg}"
	const DEFAULT_LOG_FORMAT_NORMAL = "{msg}"

	var log_level = LogLevel.INFO
	var log_format = DEFAULT_LOG_FORMAT_NORMAL
	var log_time_format = "{year}/{month}/{day} {hour}:{minute}:{second}"

	func debug(msg, raw = false):
		_log(LogLevel.DEBUG, msg, raw)

	func info(msg, raw = false):
		_log(LogLevel.INFO, msg, raw)

	func warn(msg, raw = false):
		_log(LogLevel.WARN, msg, raw)

	func error(msg, raw = false):
		_log(LogLevel.ERROR, msg, raw)

	func _log(level, msg, raw = false):
		if log_level <= level:
			if raw:
				printraw(format_log(level, msg))
			else:
				print(format_log(level, msg))

	func format_log(level, msg):
		return log_format.format(
			{
				"time": log_time_format.format(get_formatted_datatime()),
				"level": LogLevel.keys()[level],
				"msg": msg
			}
		)

	func get_formatted_datatime():
		var datetime = OS.get_datetime()
		datetime.year = "%04d" % datetime.year
		datetime.month = "%02d" % datetime.month
		datetime.day = "%02d" % datetime.day
		datetime.hour = "%02d" % datetime.hour
		datetime.minute = "%02d" % datetime.minute
		datetime.second = "%02d" % datetime.second
		return datetime