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

#include "kernel.h"
#include "process.h"

static void cm_kernel_clear_processes_heap(cm_kernel_t *self) {
    cm_process_t *count = self->processes;

    if (count == NULL) {
        return;
    }
    
    while (count < self->processes + self->processes_count) {
        count->coroutine = NULL;
    }
}

bool cm_kernel_init_static(
    cm_kernel_t *self,
    cm_process_t *target,
    size_t count
) {
    if (count == 0 || target == NULL) {
        return false;
    }

    if (self->processes != NULL) {
        return false;
    }   

    self->processes = target;
    self->processes_count = count;

    cm_kernel_clear_processes_heap(self);

    return true;
}

bool cm_kernel_drop_static(cm_kernel_t *self) {
    if (self->processes == NULL || self->processes_count == 0) {
        return false;
    }

    self->processes_count = 0;
    self->processes = (cm_process_t *) 0x00;

    return true;
}

bool cm_kernel_init(cm_kernel_t *self, size_t count) {
    if (self->processes != NULL) {
        return false;
    }

    if (count == 0) {
        return false;
    }

    size_t request_size = count * sizeof(cm_process_t);
    cm_process_t *space = (cm_process_t *) malloc(request_size);

    if (space == NULL) {
        return false;
    }
    
    self->processes = space;
    self->processes_count = count;

    cm_kernel_clear_processes_heap(self);

    return true;
}

bool cm_kernel_drop(cm_kernel_t *self) {
    if (self->processes_count == 0 || self->processes == NULL) {
        return false;
    }

    cm_process_t *processes_heap = self->processes;

    self->processes_count = 0;
    self->processes = NULL;

    free((void *) processes_heap);

    return true;
}

cm_pid_t cm_create_process(
    cm_kernel_t *self, 
    cm_coroutine_t coroutine,
    cm_event_t event
) {
    if (self->processes_count == 0 || self->processes == NULL) {
        return CM_NULL_PID;
    }

    cm_process_t *selected = self->processes;
    cm_process_t *last = self->processes + self->processes_count;

    while (selected < last && selected->coroutine != NULL) {
        ++selected;
    }

    if (selected == last) {
        return CM_NULL_PID;
    }

    selected->event = event;
    selected->coroutine = coroutine;

    cm_pid_t result = selected - self->processes;
    result = result + 1;

    return result;
}   

bool cm_kill_process(cm_kernel_t *self, cm_pid_t target_pid) {
    if (self->processes == NULL || self->processes_count == 0) {
        return false;
    }

    size_t position = target_pid - 1;

    if (position >= self->processes_count) {
        return false;
    }

    cm_process_t *target = self->processes + position;
    
    target->event = cm_empty_event();
    target->coroutine = NULL;

    return true;
}