#include "event.hpp"
#include "pk.h"

#include <cstring>
#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;
	pk_arr_t<Fn> callbacks;
};
using EventArr = pk_arr_t<EventBucket<EventHandler>>;
using TickArr = pk_arr_t<EventBucket<TickEvent>>;
EventArr eventBuckets;
TickArr tickBuckets;

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;
	pk_arr *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->next; ++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);
		pk_arr_append_t(&tArr, {});
		bkt = &tArr[tArr.next-1];
	}
	if constexpr(std::is_same<Fn, TickEvent>::value) {
		TickArr &tArr = *reinterpret_cast<TickArr *>(arr);
		pk_arr_append_t(&tArr, {});
		bkt = &tArr[tArr.next-1];
	}
	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);
	pk_arr_append_t(&tBkt->callbacks, 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 (uint32_t i = 0; i < tBkt->callbacks.next; ++i) {
		if (tBkt->callbacks[i] == handler) {
			pk_arr_remove_at(&tBkt->callbacks, 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.next; ++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);
	pk_arr_append_t(&tBkt->callbacks, 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 (uint32_t i = 0; i < tBkt->callbacks.next; ++i) {
		if (tBkt->callbacks[i] == handler) {
			pk_arr_remove_at(&tBkt->callbacks, 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 (uint32_t i = 0; i < tBkt->callbacks.next; ++i) {
		tBkt->callbacks[i](d);
	}
}

void Event_Teardown() {
	pk_arr_reset(&tickBuckets);
	pk_arr_reset(&eventBuckets);
}