extends GutInternalTester

# test.gd has a StubParams variable already so this has to have a
# different name.  I thought it was too vague to just use the one
# that test.gd has
const STUB_PARAMS_PATH = 'res://addons/gut/stub_params.gd'
var StubParamsClass = GutUtils.StubParams

func find_method_meta(methods, method_name):
	var meta = null
	var idx = 0
	while (idx < methods.size() and meta == null):
		var m = methods[idx]
		if(m.name == method_name):
			meta = m
		idx += 1

	return meta

var gr = {
	stub_params = null
}

func before_each():
	gr.stub_params = StubParamsClass.new()


func test_can_make_one():
	assert_not_null(StubParamsClass.new())


func test_to_return_sets_return_value():
	gr.stub_params.to_return(7)
	assert_eq(gr.stub_params.return_val, 7)

func test_to_return_returns_self():
	var thing = gr.stub_params.to_return(7)
	assert_eq(thing, gr.stub_params)

func test_init_sets_stub_target():
	var s = StubParamsClass.new('thing')
	assert_eq(s.stub_target, 'thing')

func test_init_sets_method():
	var s = StubParamsClass.new('thing', 'method')
	assert_eq(s.stub_method, 'method')

func test_when_passed_returns_self():
	var thing = gr.stub_params.when_passed(7)
	assert_eq(thing, gr.stub_params)

func test_when_passed_sets_parameters():
	gr.stub_params.when_passed(1)
	assert_eq(gr.stub_params.parameters, [1])

func test_parameters_turn_values_into_array():
	gr.stub_params.when_passed(1,2,3)
	assert_eq(gr.stub_params.parameters, [1,2,3])

func test_can_take_up_to_10_parameters():
	gr.stub_params.when_passed(1,2,3,4,5,6,7,8,9,10)
	assert_eq(gr.stub_params.parameters.size(), 10)

func test_can_set_to_call_super():
	gr.stub_params.to_call_super()
	assert_eq(gr.stub_params.call_super, true)

func test_to_call_super_returns_self():
	var val = gr.stub_params.to_call_super()
	assert_eq(val, gr.stub_params)

func test_to_do_nothing_returns_self():
	var sp = StubParamsClass.new('thing', 'method')
	assert_eq(sp.to_do_nothing(), sp)

func test_turns_paths_into_classes():
	var sp = StubParamsClass.new(STUB_PARAMS_PATH, 'to_return')
	assert_eq(sp.stub_target, StubParamsClass)

func test_to_call_is_null_by_default():
	var sp = StubParamsClass.new(self.assert_true)
	assert_null(sp.call_this)

func test_to_call_sets_call_this():
	var sp = StubParamsClass.new(self.assert_true)
	sp.to_call(self.assert_false)
	assert_eq(sp.call_this, self.assert_false)

func test_to_call_returns_itself():
	var sp = StubParamsClass.new(self.assert_true)
	var val = sp.to_call(self.assert_false)
	assert_eq(val, sp)


# --------------
# Parameter Count and Defaults
# --------------

func test_cannot_set_parameter_count():
	gr.stub_params.logger = new_no_print_logger()
	assert_eq(gr.stub_params.parameter_count, -1)
	assert_deprecated(gr.stub_params)
	gr.stub_params.parameter_count = 99
	assert_eq(gr.stub_params.parameter_count, -1)

func test_param_count_returns_self():
	var val = gr.stub_params.param_count(3)
	assert_eq(val, gr.stub_params);


func test_param_defaults_returns_self():
	var val = gr.stub_params.param_defaults([])
	assert_eq(val, gr.stub_params)


func test_parameter_defaults_is_empty():
	assert_eq(gr.stub_params.parameter_defaults, [])

func test_param_defaults_set_parameter_defaults():
	gr.stub_params.param_defaults([1, 2, 3])
	assert_eq(gr.stub_params.parameter_defaults, [1, 2, 3])

# --------------
# Parameter Override Only
# --------------
func test_is_paramter_override_only_false_by_default():
	var sp = StubParamsClass.new()
	assert_false(sp.is_default_override_only())

func test_to_return_sets_override_flag():
	var sp = StubParamsClass.new()
	sp.param_count(10)
	sp.to_return(7)
	assert_false(sp.is_default_override_only())

func test_order_of_calls_with_to_return_does_not_matter():
	var sp = StubParamsClass.new()
	sp.to_return(7)
	sp.param_count(10)
	assert_false(sp.is_default_override_only())

func test_to_do_nothing_sets_flag():
	var sp = StubParamsClass.new()
	sp.param_count(10)
	sp.to_do_nothing()
	assert_false(sp.is_default_override_only())

func test_to_call_super_sets_flag():
	var sp = StubParamsClass.new()
	sp.param_count(10)
	sp.to_call_super()
	assert_false(sp.is_default_override_only())


# ------------------------------------------------------------------------------
# Stubbing complex parameter lists
#
# The following tests use the draw_polyline_colors method to test various
# parameter stubbing tasks.
#
# draw_polyline_colors has:
# 	4 parameters, 2 defaults
# 	parameter 3 = -1.0
# 	parameter 4 = false
# ------------------------------------------------------------------------------
func test__draw_polyline_colors__method_meta_1():
	var inst = autofree(Button.new())
	var meta = find_method_meta(inst.get_method_list(), 'draw_polyline_colors')
	var sp = StubParamsClass.new(inst, meta)
	assert_eq(sp.stub_method, meta.name)

func test__draw_polyline_colors__method_meta_2():
	var inst = autofree(Button.new())
	var meta = find_method_meta(inst.get_method_list(), 'draw_polyline_colors')
	var sp = StubParamsClass.new(inst, meta)

	assert_eq(sp.parameter_defaults, [null, null, meta.default_args[0], meta.default_args[1]])
	if(is_failing()):
		print(sp.parameter_defaults)
		meta = find_method_meta(inst.get_method_list(), 'draw_polyline_colors')
		print(meta.default_args)

func test__draw_polyline_colors__method_meta_3():
	var inst = autofree(Button.new())
	var meta = find_method_meta(inst.get_method_list(), 'draw_polyline_colors')
	var sp = StubParamsClass.new(inst, meta)
	assert_true(sp.is_default_override_only())

func test__draw_polyline_colors__method_meta_4():
	var inst = autofree(Button.new())
	var meta = find_method_meta(inst.get_method_list(), 'draw_polyline_colors')
	var sp = StubParamsClass.new(inst, meta)
	assert_eq(sp.parameter_defaults.size(), 4)

func test_cannot_stub_defaults_for_varargs():
	var inst = autofree(Node.new())
	var lgr = new_no_print_logger()
	var sp = StubParamsClass.new(inst.rpc)

	sp.logger = lgr
	sp.param_defaults([1, 2])

	assert_eq(sp.parameter_defaults, [])
	assert_logger_errored(sp)




# ------------------------------------------------------------------------------
# Test creating from Callable
# ------------------------------------------------------------------------------
func test_can_create_from_callable():
	var sp = StubParamsClass.new(self.assert_true)
	assert_eq(sp.stub_target, self, 'target')
	assert_eq(sp.stub_method, 'assert_true', 'method')

func test_can_create_from_bound_callable():
	var sp = StubParamsClass.new(self.assert_true.bind(false))
	assert_eq(sp.parameters, [false])

func test_when_callable_is_not_bound_parameters_is_null():
	var sp = StubParamsClass.new(self.assert_false)
	assert_eq(sp.parameters, null)



# ------------------------------------------------------------------------------
# Test New Flags
# ------------------------------------------------------------------------------
func test_is_not_an_override_of_any_kind_by_default():
	var sp = StubParamsClass.new()
	assert_false(sp.is_return_override(), 'return override')
	assert_false(sp.is_defaults_override(), 'defaults override')
	assert_false(sp.is_call_override(), 'call override')

func test_to_return_sets_return_override_flag():
	var sp = StubParamsClass.new()
	sp.to_return(77)
	assert_true(sp.is_return_override())

func test_to_do_nothing_sets_return_override_flag():
	var sp = StubParamsClass.new()
	sp.to_do_nothing()
	assert_true(sp.is_return_override())

func test_to_call_super_sets_call_override_flag():
	var sp = StubParamsClass.new()
	sp.to_call_super()
	assert_true(sp.is_call_override())

func test_to_call_sets_call_override_flag():
	var sp = StubParamsClass.new()
	sp.to_call(func():  print("hello"))
	assert_true(sp.is_call_override())

func test_param_defaults_sets_is_defaults_override():
	var sp = StubParamsClass.new()
	sp.param_defaults([1, 2, 3])
	assert_true(sp.is_defaults_override())

# ------------------------------------------------------------------------------
# ------------------------------------------------------------------------------
func test_stub_is_setup_when_using_dictionary():
	var sp = StubParamsClass.new(Input, GutUtils.find_method_meta(Input.get_method_list(), 'is_action_just_pressed'))
	assert_ne(sp._method_meta, {}, 'meta')
	assert_eq(sp.stub_method, 'is_action_just_pressed')

func test_stub_method_is_set_when_using_object_and_string():
	var input = Input
	print(input, '::', Input)
	var sp = StubParamsClass.new(Input, 'is_action_just_pressed')
	assert_ne(sp._method_meta, {})

# ------------------------------------------------------------------------------
# Locking
# ------------------------------------------------------------------------------
func test_after_locked_cannot_to_return():
	var sp = StubParamsClass.new()
	sp.locked = true
	sp.to_return(7)
	assert_push_error('locked')
	assert_null(sp.return_val)

func test_after_locked_cannot_to_do_nothing():
	var sp = StubParamsClass.new()
	sp.locked = true
	sp.to_do_nothing()
	assert_push_error('locked')

func test_after_locked_cannot_to_call_super():
	var sp = StubParamsClass.new()
	sp.locked = true
	sp.to_call_super()
	assert_push_error('locked')
	assert_false(sp.call_super)

func test_after_locked_cannot_param_defaults():
	var sp = StubParamsClass.new()
	sp.locked = true
	sp.param_defaults([1])
	assert_push_error('locked')
	assert_eq(sp.parameter_defaults, [])