#include "skele.h"
#include "clock.h"
#include <stk/stk.h>
#include <stk/stk_log.h>

uint64_t skele_tick_ns = 1000000000ULL / SKELE_DEFAULT_TICK_RATE;

float skele_tps = 0.0f;
uint64_t skele_tick_time_ns = 0;
uint64_t skele_tick_idle_ns = 0;

static uint8_t stk_initialized = 0;

static uint64_t tick_win_start = 0;
static uint64_t tick_ns_accum = 0;
static uint64_t tick_idle_accum = 0;
static uint32_t tick_count = 0;
static uint64_t tick_start_ns = 0;
static uint64_t idle_start_ns = 0;

void skele_set_tick_rate(uint8_t rate)
{
	skele_tick_ns = 1000000000ULL / (rate ? rate : SKELE_DEFAULT_TICK_RATE);
}

uint8_t skele_init(void)
{
	tick_win_start = skele_time_ns();
	tick_ns_accum = 0;
	tick_idle_accum = 0;
	tick_count = 0;
	skele_tps = 0.0f;
	skele_tick_time_ns = 0;
	skele_tick_idle_ns = 0;
	return SKELE_INIT_SUCCESS;
}

void skele_shutdown(void) {}

void skele_tick(void)
{
	skele_clock_tick_begin();
	skele_clock_tick_end();
}

void skele_clock_tick_begin(void) { tick_start_ns = skele_time_ns(); }

void skele_clock_tick_end(void)
{
	uint64_t now = skele_time_ns();

	tick_ns_accum += now - tick_start_ns;
	tick_count++;

	if (now - tick_win_start >= 1000000000ULL) {
		double elapsed_s = (now - tick_win_start) / 1e9;
		skele_tps = tick_count / elapsed_s;
		skele_tick_time_ns = tick_ns_accum / tick_count;
		skele_tick_idle_ns = tick_idle_accum / tick_count;

		tick_win_start = now;
		tick_ns_accum = 0;
		tick_idle_accum = 0;
		tick_count = 0;
	}
}

void skele_clock_idle_begin(void) { idle_start_ns = skele_time_ns(); }

void skele_clock_idle_end(void)
{
	tick_idle_accum += skele_time_ns() - idle_start_ns;
}

uint8_t skele_stk_setup(void)
{
	if (stk_initialized)
		return SKELE_INIT_SUCCESS;

	stk_set_log_prefix("skele");
	stk_set_module_init_fn("skele_mod_init");
	stk_set_module_shutdown_fn("skele_mod_shutdown");
	stk_set_module_name_fn("skele_mod_name");
	stk_set_module_version_fn("skele_mod_ver");
	stk_set_module_description_fn("skele_mod_desc");
	stk_set_module_deps_sym("skele_mod_deps");

	if (stk_init() != STK_INIT_SUCCESS) {
		stk_log(STK_LOG_ERROR, "failed to initialize stk");
		return SKELE_INIT_FAILURE;
	}

	stk_initialized = 1;
	stk_log(STK_LOG_INFO, "skele v%s", SKELE_VERSION);
	return SKELE_INIT_SUCCESS;
}

void skele_stk_teardown(void)
{
	if (!stk_initialized)
		return;
	stk_shutdown();
	stk_initialized = 0;
}