# -------------
# returns{} and parameters {} have the followin structure
# -------------
# {
# 	inst_id_or_path1:{
# 		method_name1: [StubParams, StubParams],
# 		method_name2: [StubParams, StubParams]
# 	},
# 	inst_id_or_path2:{
# 		method_name1: [StubParams, StubParams],
# 		method_name2: [StubParams, StubParams]
# 	}
# }
var returns = {}
var _utils = load("res://addons/gut/utils.gd").get_instance()
var _lgr = _utils.get_logger()
var _strutils = _utils.Strutils.new()


func _make_key_from_metadata(doubled):
	var to_return = doubled.__gut_metadata_.path

	if doubled.__gut_metadata_.from_singleton != "":
		to_return = str(doubled.__gut_metadata_.from_singleton)
	elif doubled.__gut_metadata_.subpath != "":
		to_return += str("-", doubled.__gut_metadata_.subpath)

	return to_return


# Creates they key for the returns hash based checked the type of object passed in
# obj could be a string of a path to a script with an optional subpath or
# it could be an instance of a doubled object.
func _make_key_from_variant(obj, subpath = null):
	var to_return = null

	match typeof(obj):
		TYPE_STRING:
			# this has to match what is done in _make_key_from_metadata
			to_return = obj
			if subpath != null and subpath != "":
				to_return += str("-", subpath)
		TYPE_OBJECT:
			if _utils.is_instance(obj):
				to_return = _make_key_from_metadata(obj)
			elif _utils.is_native_class(obj):
				to_return = _utils.get_native_class_name(obj)
			else:
				to_return = obj.resource_path

	return to_return


func _add_obj_method(obj, method, subpath = null):
	var key = _make_key_from_variant(obj, subpath)
	if _utils.is_instance(obj):
		key = obj

	if !returns.has(key):
		returns[key] = {}
	if !returns[key].has(method):
		returns[key][method] = []

	return key


# ##############
# Public
# ##############


# Searches returns for an entry that matches the instance or the class that
# passed in obj is.
#
# obj can be an instance, class, or a path.
func _find_stub(obj, method, parameters = null, find_overloads = false):
	var key = _make_key_from_variant(obj)
	var to_return = null

	if _utils.is_instance(obj):
		if returns.has(obj) and returns[obj].has(method):
			key = obj
		elif obj.get("__gut_metadata_"):
			key = _make_key_from_metadata(obj)

	if returns.has(key) and returns[key].has(method):
		var param_match = null
		var null_match = null
		var overload_match = null

		for i in range(returns[key][method].size()):
			if returns[key][method][i].parameters == parameters:
				param_match = returns[key][method][i]

			if returns[key][method][i].parameters == null:
				null_match = returns[key][method][i]

			if returns[key][method][i].has_param_override():
				overload_match = returns[key][method][i]

		if find_overloads and overload_match != null:
			to_return = overload_match
		# We have matching parameter values so return the stub value for that
		elif param_match != null:
			to_return = param_match
		# We found a case where the parameters were not specified so return
		# parameters for that.  Only do this if the null match is not *just*
		# a paramerter override stub.
		elif null_match != null and !null_match.is_param_override_only():
			to_return = null_match
		else:
			_lgr.warn(
				str(
					"Call to [",
					method,
					"] was not stubbed for the supplied parameters ",
					parameters,
					".  Null was returned."
				)
			)

	return to_return


func add_stub(stub_params):
	if stub_params.stub_method == "_init":
		_lgr.error("You cannot stub _init.  Super's _init is ALWAYS called.")
	else:
		var key = _add_obj_method(
			stub_params.stub_target, stub_params.stub_method, stub_params.target_subpath
		)
		returns[key][stub_params.stub_method].append(stub_params)


# Gets a stubbed return value for the object and method passed in.  If the
# instance was stubbed it will use that, otherwise it will use the path and
# subpath of the object to try to find a value.
#
# It will also use the optional list of parameter values to find a value.  If
# the object was stubbed with no parameters than any parameters will match.
# If it was stubbed with specific parameter values then it will try to match.
# If the parameters do not match BUT there was also an empty parameter list stub
# then it will return those.
# If it cannot find anything that matches then null is returned.for
#
# Parameters
# obj:  this should be an instance of a doubled object.
# method:  the method called
# parameters:  optional array of parameter vales to find a return value for.
func get_return(obj, method, parameters = null):
	var stub_info = _find_stub(obj, method, parameters)

	if stub_info != null:
		return stub_info.return_val
	else:
		return null


func should_call_super(obj, method, parameters = null):
	if _utils.non_super_methods.has(method):
		return false

	var stub_info = _find_stub(obj, method, parameters)

	var is_partial = false
	if typeof(obj) != TYPE_STRING:  # some stubber tests test with strings
		is_partial = obj.__gut_metadata_.is_partial
	var should = is_partial

	if stub_info != null:
		should = stub_info.call_super
	elif !is_partial:
		# this log message is here because of how the generated doubled scripts
		# are structured.  With this log msg here, you will only see one
		# "unstubbed" info instead of multiple.
		_lgr.info("Unstubbed call to " + method + "::" + _strutils.type2str(obj))
		should = false

	return should


func get_parameter_count(obj, method):
	var to_return = null
	var stub_info = _find_stub(obj, method, null, true)

	if stub_info != null and stub_info.has_param_override():
		to_return = stub_info.parameter_count

	return to_return


func get_default_value(obj, method, p_index):
	var to_return = null
	var stub_info = _find_stub(obj, method, null, true)
	if (
		stub_info != null
		and stub_info.parameter_defaults != null
		and stub_info.parameter_defaults.size() > p_index
	):
		to_return = stub_info.parameter_defaults[p_index]

	return to_return


func clear():
	returns.clear()


func get_logger():
	return _lgr


func set_logger(logger):
	_lgr = logger


func to_s():
	var text = ""
	for thing in returns:
		text += str("-- ", thing, " --\n")
		for method in returns[thing]:
			text += str("\t", method, "\n")
			for i in range(returns[thing][method].size()):
				text += "\t\t" + returns[thing][method][i].to_s() + "\n"

	if text == "":
		text = "Stubber is empty"

	return text