#include <stddef.h>
#include <stdint.h>

#include "task.h"
#include "kernel.h"
#include "scheduler.h"

bool zv_kernel_init(zv_kernel_t *self, zv_task_t *tasks, zv_tid_t count) {
    if (self == NULL || tasks == NULL || count < 1) {
        return false;
    }

    self->tasks = tasks;
    self->tasks_count = count;
    self->scheduler = ZV_SCHEDULER_PRIORITY_AGING;

    for (zv_tid_t count = 0; count < self->tasks_count; ++count) {
        zv_task_t *current = self->tasks + count;
        current->state = ZV_TASK_EMPTY;
    }
    
    return true;
}


bool zv_kernel_boot(zv_kernel_t *self) {
    if (self == NULL || self->tasks == NULL || self->tasks_count < 1) {
        return false;
    }

    while (true) {
        __zv_scheduler_update_tasks(self);
        zv_task_t *next = __zv_scheduler_find_task(self);

        if (next == NULL) {
            break;
        }

        __zv_scheduler_run_task(self, next);
    }   
    
    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) {
    if (self->tasks_count <= target) {
        return NULL;
    }

    return self->tasks + target;
}

zv_tid_t zv_kernel_create_process(
    zv_kernel_t *self,
    zv_worker_t worker,
    zv_priority_t priority,
    void *param
) {
    if (self == NULL || worker == NULL) {
        return ZV_TID_NULL;
    }

    zv_tid_t target_tid = __zv_kernel_get_empty_slot(self);
    zv_task_t *target = __zv_kernel_get_task(self, target_tid);

    if (target == NULL) {
        return ZV_TID_NULL;
    }

    target->worker = worker;
    target->param = param;
    target->priority = priority;
    
    target->event.type = ZV_EVENT_EMPTY;
    target->event.content.unumber = 0x00;
    
    target->state = ZV_TASK_READY;
    return target_tid;
}

bool zv_kernel_kill_process(
    zv_kernel_t *self,
    zv_tid_t target_tid
) {
    if (self == NULL) {
        return false;
    }

    zv_task_t *target = __zv_kernel_get_task(self, target_tid);

    if (target == NULL) {
        return false;
    }

    target->state = ZV_TASK_EMPTY;
    return true;
}

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