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

#ifndef ZIVUOS_USE_STATIC
#include <malloc.h>
#endif

#include "status.h"
#include "models.h"
#include "process.h"
#include "kernel.h"

/* Dynamic kernel creating. */
#ifndef ZIVUOS_USE_STATIC

zv_kernel_t * zv_kernel_create() {
    zv_kernel_t *self = (zv_kernel_t *) malloc(sizeof(zv_kernel_t));

    if (self == NULL) {
        return NULL;
    }

    self->is_dynamic = true;
    self->processes = NULL;
    self->processes_count = 0;
    self->current_max_pid = 0;

    return self;
}

void zv_kernel_close(zv_kernel_t *self) {
    if (!self->is_dynamic) {
        return;
    }

    zv_process_t *current = self->processes;

    while (current->next != NULL) {
        current = zv_process_remove(current);
    }

    free(self);
}

/* Static kernel creating. */
#else

zv_kernel_t * zv_kernel_create() {
    return NULL;
}

void zv_kernel_close(zv_kernel_t *self) {
    /* Not require to free not alloced resources. */
}

#endif

zv_process_t * zv_kernel_get_oldest(zv_kernel_t *self) {
    zv_process_t *current = self->processes;
    zv_pid_t count = 0;
    zv_pid_t max = self->processes_count;

    if (current == NULL || max == 0) {
        return NULL;
    }

    while (current->next != NULL) {
        current = current->next;
        
        if (++count >= max) {
            return current;
        }
    }

    return current;
}

zv_process_t * zv_kernel_select_process(zv_kernel_t *self, zv_pid_t target) {
    zv_process_t *current = self->processes;
    zv_pid_t count = self->processes_count;

    while (true) {
        if (current == NULL || count == 0) {
            return NULL;
        }

        if (current->pid == target) {
            return current;
        }

        --count;
        current = current->next;
    }
}   

zv_pid_t zv_kernel_attach_process(zv_kernel_t *self, zv_process_t *target) {
    zv_process_t *oldest = zv_kernel_get_oldest(self); 
    
    ++self->processes_count;
    ++self->current_max_pid;

    target->pid = self->current_max_pid;
    oldest->next = target;
    
    return target->pid;
}

/* Dynamic process creating. */
#ifndef ZIVUOS_USE_STATIC

zv_process_t * zv_kernel_create_process(zv_kernel_t *self) {
    zv_process_t *target = zv_process_create();

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

    target->status = ZV_STATUS_CREATING;
    zv_kernel_attach_process(self, target);
    
    return target;
}

#else

zv_process_t * zv_kernel_create_process(zv_kernel_t *self) {
    return NULL;
}

#endif