#include "arc/engine/engine.h"

//NOTE: some of this file is temporary, mostly to get smthn running so I can test out different ideas
#include "arc/engine/state.h"
#include "arc/graphics/window.h"
#include "arc/graphics/renderer.h"
#include "arc/input/mouse.h"
#include "arc/input/keyboard.h"
#include "arc/std/bool.h"
#include "arc/std/errno.h"
#include "arc/std/handler.h"
#include <stdlib.h>
#include <time.h>

void ARC_EngineData_VectorDestroyStateFn(void *data){
    ARC_State_Destroy((ARC_State *)data);
}

void ARC_EngineData_Create(ARC_EngineData **data, ARC_Point windowSize){
    *data = (ARC_EngineData *)malloc(sizeof(ARC_EngineData));
    (*data)->window       = NULL;
    (*data)->renderer     = NULL;
    (*data)->input        = NULL;
    (*data)->keyboard     = NULL;
    (*data)->mouse        = NULL;
    (*data)->entitySystem = NULL;

    ARC_Vector_DestroyDataFn destroyDataFn = ARC_EngineData_VectorDestroyStateFn;
    ARC_Handler_Create(&((*data)->state), &destroyDataFn);

    (*data)->dt = 0.0;
    (*data)->running = ARC_False;
    (*data)->windowSize = windowSize;

    ARC_WindowInfo windowInfo = (ARC_WindowInfo){ "title", (*data)->windowSize.x, (*data)->windowSize.y };
    ARC_Window_Create(&((*data)->window), &windowInfo);
    if(arc_errno){
        free(data);
        return;
    }

    ARC_Renderer_CreateWithEngineData(&((*data)->renderer), *data);
    if(arc_errno){
        ARC_Window_Destroy((*data)->window);
        free(data);
    }

    ARC_Input_CreateWithEngineData(&((*data)->input), *data);

    (*data)->keyboard = ARC_Input_GetKeyboard((*data)->input);
    (*data)->mouse    = ARC_Input_GetMouse((*data)->input);

    ARC_EntitySystem_Create(&((*data)->entitySystem));
}

void ARC_EngineData_Destroy(ARC_EngineData *data){
    ARC_EntitySystem_Destroy(data->entitySystem);
    ARC_Mouse_Destroy(data->mouse);
    ARC_Keyboard_Destroy(data->keyboard);
    ARC_Renderer_Destroy(data->renderer);
    ARC_Window_Destroy(data->window);
    ARC_Handler_Destroy(data->state);
}

void ARC_Engine_RunUncapped(ARC_EngineData *data){
    if(arc_errno){
        return;
    }

    //TODO: probably want to do this in a better way
    struct timespec currentTime;
    struct timespec lastTime;

    clock_gettime(CLOCK_MONOTONIC, &currentTime);

    lastTime = currentTime;

    data->running = ARC_True;
    while(data->running){
        clock_gettime(CLOCK_MONOTONIC, &currentTime);
        data->dt = (currentTime.tv_sec + (currentTime.tv_nsec * 0.000000001)) - (lastTime.tv_sec + (lastTime.tv_nsec * 0.000000001));
        lastTime = currentTime;

        data->running = ARC_Input_Update(data->input);

        ARC_Handler_Clean(data->state);

        ARC_Handler_Iterate(data->state, ARC_State_Update);

        ARC_Renderer_Clear(data->renderer);

        ARC_Handler_Iterate(data->state, ARC_State_Render);

        ARC_Renderer_Render(data->renderer);
    }
}