#include "event.hpp"
#include "dynamic-array.hpp"

#include <type_traits>

struct BaseEventBucket {
	char name[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
};

template<typename Fn>
struct EventBucket : public BaseEventBucket {
	using BaseEventBucket::name;
	DynArray<Fn> callbacks{8};
};
using EventArr = DynArray<EventBucket<EventHandler>>;
using TickArr = DynArray<EventBucket<TickEvent>>;
EventArr eventBuckets{0, nullptr};
TickArr tickBuckets{0, nullptr};

template<typename Fn>
void EventBucketFind(const char *name, BaseEventBucket*& bkt) {
	assert(strlen(name) <= 16);
	char safeName[16];
	memset(safeName, '\0', 16);
	memcpy(safeName, name, strlen(name));

	BaseEventBucket *baseBkt = nullptr;
	DynArrayBase *arr = nullptr;

	if constexpr(std::is_same<Fn, EventHandler>::value) {
		arr = &eventBuckets;
	}
	if constexpr(std::is_same<Fn, TickEvent>::value) {
		arr = &tickBuckets;
	}
	assert(arr != nullptr);
	for (long i = 0; i < arr->elementCount; ++i) {
		if constexpr(std::is_same<Fn, EventHandler>::value) {
			EventArr &tArr = *reinterpret_cast<EventArr *>(arr);
			baseBkt = &tArr[i];
		}
		if constexpr(std::is_same<Fn, TickEvent>::value) {
			TickArr &tArr = *reinterpret_cast<TickArr *>(arr);
			baseBkt = &tArr[i];
		}
		assert(baseBkt != nullptr);
		if (strncmp(safeName, baseBkt->name, 16) == 0) {
			bkt = baseBkt;
			return;
		}
	}
	if constexpr(std::is_same<Fn, EventHandler>::value) {
		EventArr &tArr = *reinterpret_cast<EventArr *>(arr);
		bkt = &tArr.Push();
	}
	if constexpr(std::is_same<Fn, TickEvent>::value) {
		TickArr &tArr = *reinterpret_cast<TickArr *>(arr);
		bkt = &tArr.Push();
	}
	assert(bkt != nullptr);
	memcpy(bkt->name, safeName, 16);
}

template<>
void Event_RegisterCallback<EventHandler>(const char *name, EventHandler handler) {
	assert(handler != nullptr);
	BaseEventBucket *bkt = nullptr;
	EventBucketFind<EventHandler>(name, bkt);
	EventBucket<EventHandler> *tBkt = reinterpret_cast<EventBucket<EventHandler> *>(bkt);
	tBkt->callbacks.Push(handler);
}

template<>
void Event_UnregisterCallback<EventHandler>(const char *name, EventHandler handler) {
	assert(handler != nullptr);
	BaseEventBucket *bkt = nullptr;
	EventBucketFind<EventHandler>(name, bkt);
	EventBucket<EventHandler> *tBkt = reinterpret_cast<EventBucket<EventHandler> *>(bkt);
	for (int64_t i = 0; i < tBkt->callbacks.Count(); ++i) {
		if (tBkt->callbacks[i] == handler) {
			tBkt->callbacks.Remove(i);
			break;
		}
	}
}

template<>
void Event_Dispatch<EventHandler>(const char *name) {
	BaseEventBucket *bkt = nullptr;
	EventBucketFind<EventHandler>(name, bkt);
	EventBucket<EventHandler> *tBkt = reinterpret_cast<EventBucket<EventHandler> *>(bkt);
	for (int64_t i = 0; i < tBkt->callbacks.Count(); ++i) {
		tBkt->callbacks[i]();
	}
}

template<>
void Event_RegisterCallback<TickEvent>(const char *name, TickEvent handler) {
	assert(handler != nullptr);
	BaseEventBucket *bkt = nullptr;
	EventBucketFind<TickEvent>(name, bkt);
	EventBucket<TickEvent> *tBkt = reinterpret_cast<EventBucket<TickEvent> *>(bkt);
	tBkt->callbacks.Push(handler);
}

template<>
void Event_UnregisterCallback<TickEvent>(const char *name, TickEvent handler) {
	assert(handler != nullptr);
	BaseEventBucket *bkt = nullptr;
	EventBucketFind<TickEvent>(name, bkt);
	EventBucket<TickEvent> *tBkt = reinterpret_cast<EventBucket<TickEvent> *>(bkt);
	for (int64_t i = 0; i < tBkt->callbacks.Count(); ++i) {
		if (tBkt->callbacks[i] == handler) {
			tBkt->callbacks.Remove(i);
			break;
		}
	}
}

template<>
void Event_Dispatch<TickEvent, double>(const char *name, double d) {
	BaseEventBucket *bkt = nullptr;
	EventBucketFind<TickEvent>(name, bkt);
	EventBucket<TickEvent> *tBkt = reinterpret_cast<EventBucket<TickEvent> *>(bkt);
	for (int64_t i = 0; i < tBkt->callbacks.Count(); ++i) {
		tBkt->callbacks[i](d);
	}
}

void Event_Teardown() {
	tickBuckets.~DynArray();
	eventBuckets.~DynArray();
}