@[has_globals]
module main

import eventbus

struct EventData {
	data string
	n    int
}

struct FakeReceiver {
	ok bool
}

fn test_eventbus_string() {
	ev_data := &EventData{'hello', 1}
	mut eb := eventbus.new[string]()
	eb.subscriber.subscribe_once('on_test', on_test_without_receiver)
	assert eb.has_subscriber('on_test')
	assert !eb.has_subscriber('not_exist')
	assert eb.subscriber.is_subscribed('on_test')
	eprintln('> publishing to on_test 1')
	reset_ncalls()
	eb.publish('on_test', eb, ev_data)
	assert calls_of_on_test_without_receiver == 1
	reset_ncalls()
	assert !eb.has_subscriber('on_test')
	assert !eb.subscriber.is_subscribed('on_test')
	// subscribe 3 times more:
	eb.subscriber.subscribe('on_test', on_test_without_receiver)
	eb.subscriber.subscribe('on_test', on_test_without_receiver)
	eb.subscriber.subscribe('on_test', on_test_without_receiver)
	assert eb.has_subscriber('on_test')
	assert eb.subscriber.is_subscribed('on_test')
	eprintln('> publishing to on_test 2')
	reset_ncalls()
	eb.publish('on_test', eb, &EventData{'hello', 2})
	assert calls_of_on_test_without_receiver == 1, 'even though we had more than 1 subscription, to the same event, the callback should be called just once because of the deduplication'
	reset_ncalls()
	eb.clear_all()
	assert !eb.has_subscriber('on_test')
	assert !eb.subscriber.is_subscribed('on_test')
	// check that unsubscription actually remove the handler:
	reset_ncalls()
	eb.publish('on_test', eb, &EventData{'hello', 3})
	assert calls_of_on_test_without_receiver == 0
	reset_ncalls()
}

enum Events {
	event_1
	event_2
	event_3
}

fn test_eventbus_enum() {
	reset_ncalls()
	ev_data := &EventData{'hello', 1}
	mut eb := eventbus.EventBus.new[Events]()
	eprintln('> subscribing once on_test for Events enum bus ...')
	eb.subscriber.subscribe_once(Events.event_1, on_test_without_receiver)
	assert eb.has_subscriber(Events.event_1)
	assert !eb.has_subscriber(Events.event_2)
	assert eb.subscriber.is_subscribed(Events.event_1)
	eprintln('> publishing even_1 ...')
	eb.publish(Events.event_1, eb, ev_data)
	assert !eb.has_subscriber(Events.event_1)
	assert !eb.subscriber.is_subscribed(Events.event_1)
	eb.subscriber.subscribe(Events.event_1, on_test_without_receiver)
	assert eb.has_subscriber(Events.event_1)
	assert eb.subscriber.is_subscribed(Events.event_1)
	eb.clear_all()
	assert !eb.has_subscriber(Events.event_1)
	assert !eb.subscriber.is_subscribed(Events.event_1)

	assert calls_of_on_test_without_receiver == 1
	assert call_of_on_test_with_receiver == 0
}

fn test_eventbus_int() {
	reset_ncalls()
	ev_data := &EventData{'hello', 1}
	mut eb := eventbus.EventBus.new[int]()
	eprintln('> subscribing once on_test for int bus ...')
	eb.subscriber.subscribe_once(9999, on_test_without_receiver)
	assert eb.has_subscriber(9999)
	assert !eb.has_subscriber(1111)
	assert eb.subscriber.is_subscribed(9999)
	eb.publish(9999, eb, ev_data)
	assert !eb.has_subscriber(9999)
	assert !eb.subscriber.is_subscribed(9999)
	eb.subscriber.subscribe(9999, on_test_without_receiver)
	assert eb.has_subscriber(9999)
	assert eb.subscriber.is_subscribed(9999)
	eb.clear_all()
	assert !eb.has_subscriber(9999)
	assert !eb.subscriber.is_subscribed(9999)

	assert calls_of_on_test_without_receiver == 1
	assert call_of_on_test_with_receiver == 0
}

fn test_subscribe_method() {
	reset_ncalls()
	// given
	mut eb := eventbus.new[string]()
	r := FakeReceiver{}
	assert !eb.subscriber.is_subscribed_method('on_test_with_receiver', r)
	// when
	eb.subscriber.subscribe_method('on_test_with_receiver', on_test_with_receiver, r)
	// then
	assert eb.subscriber.is_subscribed_method('on_test_with_receiver', r)

	assert calls_of_on_test_without_receiver == 0
	assert call_of_on_test_with_receiver == 0
}

fn test_unsubscribe_method() {
	reset_ncalls()
	// given
	mut eb := eventbus.new[string]()
	r := FakeReceiver{}
	r2 := FakeReceiver{}
	// when
	eb.subscriber.subscribe_method('on_test_with_receiver', on_test_with_receiver, r)
	eb.subscriber.subscribe_method('on_test_with_receiver', on_test_with_receiver, r2)
	eb.subscriber.unsubscribe_method('on_test_with_receiver', r)
	// then
	assert !eb.subscriber.is_subscribed_method('on_test_with_receiver', r)
	assert eb.subscriber.is_subscribed_method('on_test_with_receiver', r2)

	assert calls_of_on_test_without_receiver == 0
	assert call_of_on_test_with_receiver == 0
}

fn test_publish() {
	reset_ncalls()
	// given
	ev_data := &EventData{'hello', 1}
	mut eb := eventbus.new[string]()
	r1 := FakeReceiver{}
	r2 := FakeReceiver{}
	// when
	eb.subscriber.subscribe_once('on_test', on_test_without_receiver)
	eprintln('> publishing once 1 ...')
	eb.publish('on_test', eb, ev_data)
	// then
	assert !eb.subscriber.is_subscribed('on_test')
	assert calls_of_on_test_without_receiver == 1

	eb.subscriber.subscribe_method('on_test', on_test_with_receiver, r1) // subscribe r1 3 times
	eb.subscriber.subscribe_method('on_test', on_test_with_receiver, r1)
	eb.subscriber.subscribe_method('on_test', on_test_with_receiver, r1)
	eb.subscriber.subscribe_method('on_test', on_test_with_receiver, r2) // subscribe r2 3 times
	eb.subscriber.subscribe_method('on_test', on_test_with_receiver, r2)
	eb.subscriber.subscribe_method('on_test', on_test_with_receiver, r2)
	eb.publish('on_test', eb, &EventData{'hello', 123})

	assert calls_of_on_test_without_receiver == 1 // this should not change, since the subscription was done through subscribe_once.
	assert call_of_on_test_with_receiver == 2 // make sure that even though we subscribed several times, only 2 calls are made (once per receiver)
}

fn test_publish_with_receiver() {
	reset_ncalls()
	// given
	mut eb := eventbus.new[string]()
	ev_data := &EventData{'hello', 1}
	r := FakeReceiver{}
	// when
	eb.subscriber.subscribe_method('on_test_with_receiver', on_test_with_receiver, r)
	eb.publish('on_test_with_receiver', eb, ev_data)

	assert calls_of_on_test_without_receiver == 0
	assert call_of_on_test_with_receiver == 1
}

fn test_unsubscribe_reveiver() {
	reset_ncalls()
	// given
	mut eb := eventbus.new[string]()
	r := &FakeReceiver{}
	// when
	eb.subscriber.subscribe_method('on_test_with_receiver', on_test_with_receiver, r)
	eb.subscriber.subscribe_method('on_test', on_test_without_receiver, r)
	eb.subscriber.unsubscribe_receiver(r)
	assert !eb.subscriber.is_subscribed_method('on_test_with_receiver', r)
	assert !eb.subscriber.is_subscribed_method('on_test', r)

	assert calls_of_on_test_without_receiver == 0
	assert call_of_on_test_with_receiver == 0
}

fn on_test_without_receiver(receiver voidptr, ev &EventData, sender voidptr) {
	calls_of_on_test_without_receiver++
	eprintln('>> ${@LOCATION:-80s} | receiver: ${voidptr(receiver):16} | sender: ${sender:16} | ev.data: ${ev.data} | ev.n: ${ev.n}')
	assert receiver == 0
	assert sender != 0
	assert ev.data == 'hello'
}

fn on_test_with_receiver(receiver &FakeReceiver, ev &EventData, sender voidptr) {
	call_of_on_test_with_receiver++
	eprintln('>> ${@LOCATION:-80s} | receiver: ${voidptr(receiver):16} | sender: ${sender:16} | ev.data: ${ev.data} | ev.n: ${ev.n}')
	assert receiver.ok == false
	assert sender != 0
	assert ev.data == 'hello'
}

__global calls_of_on_test_without_receiver = 0
__global call_of_on_test_with_receiver = 0

fn reset_ncalls() {
	calls_of_on_test_without_receiver = 0
	call_of_on_test_with_receiver = 0
}