# res://tests/test_eventbus.gd
class_name EventBusTests
extends Node

func _ready():
	run_tests()

func run_tests():
	test_subscribe_and_publish()
	test_dispose_subscription()
	test_cancel_scope()
	test_multiple_subscribers()
	
	# Test function: Test subscribing and publishing events
func test_subscribe_and_publish() -> void:
	var bus: DefaultEventBus = DefaultEventBus.new()
	var scope: DefaultScope = DefaultScope.new()
	var event_received: Flag = Flag.new()

	var event_handler = func(_event: Event) -> int:
		event_received.value = true
		return EventResult.ResultType.KEEP_SUBSCRIPTION

	bus.subscribe_to(scope, "TestEvent", event_handler)
	var event: TestEvent = TestEvent.new(self)
	bus.publish(scope, event)

	# Assert that the event was received
	assert(event_received.value == true, "Event was not received by subscriber")
	bus.dispose()
	
	# Test function: Test disposing of a subscription after handling an event
func test_dispose_subscription() -> void:
	var bus: DefaultEventBus = DefaultEventBus.new()
	var scope: DefaultScope = DefaultScope.new()
	var event_received_times: Counter = Counter.new()

	var event_handler = func(_event: Event) -> int:
		event_received_times.value += 1
		return EventResult.ResultType.DISPOSE_SUBSCRIPTION

	bus.subscribe_to(scope, "TestEvent", event_handler)
	var event: TestEvent = TestEvent.new(self)
	bus.publish(scope, event)
	bus.publish(scope, event)  # Publish a second time

	# Assert that the event handler was called only once
	assert(event_received_times.value == 1, "Event handler should have been called only once due to disposal")
	bus.dispose()
	
	# Test function: Test canceling an event scope
func test_cancel_scope() -> void:
	var bus: DefaultEventBus = DefaultEventBus.new()
	var scope: DefaultScope = DefaultScope.new()
	var event_received: Flag = Flag.new()

	var event_handler = func(_event: Event) -> int:
		event_received.value = true
		return EventResult.ResultType.KEEP_SUBSCRIPTION

	bus.subscribe_to(scope, "TestEvent", event_handler)
	bus.cancel_scope(scope)
	var event: TestEvent = TestEvent.new(self)
	bus.publish(scope, event)

	# Assert that the event was not received after scope cancellation
	assert(event_received.value == false, "Event should not have been received after scope cancellation")
	bus.dispose()
	

# Test function: Test multiple subscribers receiving the same event
func test_multiple_subscribers() -> void:
	var bus: DefaultEventBus = DefaultEventBus.new()
	var scope: DefaultScope = DefaultScope.new()
	var event_received_by_handler1: Flag = Flag.new()
	var event_received_by_handler2: Flag = Flag.new()

	var event_handler1 = func(_event: Event) -> int:
		event_received_by_handler1.value = true
		return EventResult.ResultType.KEEP_SUBSCRIPTION

	var event_handler2 = func(_event: Event) -> int:
		event_received_by_handler2.value = true
		return EventResult.ResultType.KEEP_SUBSCRIPTION

	bus.subscribe_to(scope, "TestEvent", event_handler1)
	bus.subscribe_to(scope, "TestEvent", event_handler2)
	var event: TestEvent = TestEvent.new(self)
	bus.publish(scope, event)

	# Assert that both handlers received the event
	assert(event_received_by_handler1.value == true, "First handler did not receive event")
	assert(event_received_by_handler2.value == true, "Second handler did not receive event")
	bus.dispose()

class Flag:
	var value = false

class Counter:
	var value = 0
	
class TestEvent extends Event:
	func _init(_source: Variant = null) -> void:
		super(_source)
		type = "TestEvent"