#include <zivuos.h>
#include <stddef.h>

static inline void __zv_kernel_init_task(zv_task_t *target) {
    target->state = ZV_TASK_EMPTY;
    target->param = NULL;
    target->event.type = ZV_EVENT_EMPTY;
    target->event.content.unumber = 0;
    target->age = 0;
    target->priority = 0;
    target->worker = NULL;
}

/**
 * @brief That initialize kernel structure.
 * @param self Pointer to kernel structure to work on.
 * @param tasks Pointer to tasks stack.
 * @param count Number of tasks slots on stack.
 * @return True when kernel initialized success or false when not.
 */
bool zv_kernel_init(zv_kernel_t *self, zv_task_t *tasks, zv_tid_t count) {
    if (self == NULL || tasks == NULL || count < 2) {
        return false;
    }

    self->tasks = tasks;
    self->tasks_count = count;
    self->idle_worker = zv_idle_worker_default;

    for (zv_tid_t count = 0; count < self->tasks_count; ++count) {
        __zv_kernel_init_task(self->tasks + count);
    }

    return true;
}

/** 
 * @brief That boot OS. It return when task stack is empty.
 * @return True when everything is executed, and all tasks had been killed.
 *         False when something went wrong.
 */
bool zv_kernel_boot(zv_kernel_t *self) {
    while (true) {
        bool any_task_exists = __zv_scheduler_single_loop(self);

        if (!any_task_exists) {
            return true;
        }
    }

    return false;
}


zv_tid_t zv_kernel_create_process(
    zv_kernel_t *self,
    zv_worker_t worker,
    zv_priority_t priority,
    void *param
) {
    zv_tid_t slot = __zv_kernel_get_empty_slot(self);

    if (slot == ZV_TID_NULL) {
        return ZV_TID_NULL;
    }

    zv_task_t *target = self->tasks + slot;

    target->param = param;
    target->worker = worker;
    target->age = 0;
    target->priority = priority;
    target->state = ZV_TASK_READY;

    return slot;
}

bool zv_kernel_kill_process(
    zv_kernel_t *self,
    zv_tid_t target
) {
    zv_task_t *current = self->tasks + target; 
    
    if (current->state == ZV_TASK_EMPTY) {
        return false;
    }

    current->state = ZV_TASK_EMPTY;
    return true;
}

zv_tid_t __zv_kernel_get_empty_slot(zv_kernel_t *self) {
    for (zv_tid_t count = 0; count < self->tasks_count; ++count) {
        zv_task_t *current = self->tasks + count;

        if (current->state == ZV_TASK_EMPTY) {
            return count;
        }
    }

    return ZV_TID_NULL;
}

zv_task_t * __zv_kernel_get_task(zv_kernel_t *self, zv_tid_t target) {
    return self->tasks + target;
}

zv_tid_t __zv_kernel_get_tid(zv_kernel_t *self, zv_task_t *target) {
    return target - self->tasks;
}