#include "HydraMeshSystem.h"
#include "../HydraECS.h"
#include "../../engine/HydraEngine.h"
#include "../components/HydraMeshComponent.h"
#include "../../buffer/HydraBufferManager.h"
#include "../../scheduler/HydraTaskScheduler.h"
#include "../../task/buffer/HydraCreateVertexBufferTask.hpp"
#include "../../task/buffer/HydraDeleteVertexBufferTask.hpp"
#include "../../task/buffer/HydraUpdateVertexBufferTask.hpp"
#include "../../mesh/HydraMeshManager.h"
void HydraMeshSystem::Initialise()
{

}



void HydraMeshSystem::InitialiseComponent(HydraID entity_id)
{
    HydraECS* ecs = GetEngine()->ECS();

    HydraBufferManager *buffer_manager = GetEngine()->BufferManager();
    HydraMeshComponent& mesh_comp = ecs->GetComponent<HydraMeshComponent>(entity_id);

    HydraMeshManager* mesh_man = GetEngine()->MeshManager();
    HydraMesh* mesh = mesh_man->GetMesh(mesh_comp.mesh_id);
    
    if(mesh->vertexes.size() > 0)
    {
        mesh_comp.origin = glm::vec3(mesh->vertexes[0].position[0], mesh->vertexes[0].position[1], mesh->vertexes[0].position[2]);
        mesh_comp.extent = mesh_comp.origin;
        for(StandardVertex vert : mesh->vertexes)
        {
            if(vert.position[0] < mesh_comp.origin.x)
            {
                mesh_comp.origin.x = vert.position[0];
            }
            if(vert.position[1] < mesh_comp.origin.y)
            {
                mesh_comp.origin.y = vert.position[1];
            }
            if(vert.position[2] < mesh_comp.origin.z)
            {
                mesh_comp.origin.z = vert.position[2];
            }
            if(vert.position[0] > mesh_comp.extent.x)
            {
                mesh_comp.extent.x = vert.position[0];
            }
            if(vert.position[1] > mesh_comp.extent.y)
            {
                mesh_comp.extent.y = vert.position[1];
            }
            if(vert.position[2] > mesh_comp.extent.z)
            {
                mesh_comp.extent.z = vert.position[2];
            }
        }
    }   


    uint32_t vertex_buffer_size = sizeof(StandardVertex) * mesh->vertexes.size();
    uint32_t index_buffer_size = sizeof(uint32_t) * mesh->indexes.size();

    uint32_t triangle_count = mesh->indexes.size();// / 3;
    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();

    //Create VAO and Vertex Buffer storage
    HydraID create_vertex_task_id = task_scheduler->CreateTask<HydraCreateVertexBufferTask>(HydraThreadAffinity::Render);
    HydraCreateVertexBufferTask *vertex_task = static_cast<HydraCreateVertexBufferTask *>(task_scheduler->GetTask(create_vertex_task_id));    
    vertex_task->Intialise(vertex_buffer_size, index_buffer_size, triangle_count, &mesh_comp.vertex_buffer_id);
    task_scheduler->WaitForTask(create_vertex_task_id);

    //Update vertex buffer
    HydraID update_buffer_task_id = task_scheduler->CreateTask<HydraUpdateVertexBufferTask>(HydraThreadAffinity::Render);
    HydraUpdateVertexBufferTask *vertex_update_task = static_cast<HydraUpdateVertexBufferTask *>(task_scheduler->GetTask(update_buffer_task_id));
    vertex_update_task->Intialise(mesh_comp.vertex_buffer_id, &mesh->vertexes[0], &mesh->indexes[0]);
    task_scheduler->WaitForTask(update_buffer_task_id);
    mesh_comp.mesh_state = HYDRA_STATE::Ready;
}

void HydraMeshSystem::DestroyComponent(HydraID entity_id)
{
    HydraECS* ecs = GetEngine()->ECS();
    HydraTaskScheduler *task_scheduler = GetEngine()->TaskScheduler();

    HydraBufferManager *buffer_manager = GetEngine()->BufferManager();
    HydraMeshComponent mesh_comp = ecs->GetComponent<HydraMeshComponent>(entity_id);
    
    HydraID delete_vertex_task_id = task_scheduler->CreateTask<HydraDeleteVertexBufferTask>(HydraThreadAffinity::Render);
    HydraDeleteVertexBufferTask *vertex_task = static_cast<HydraDeleteVertexBufferTask *>(task_scheduler->GetTask(delete_vertex_task_id));    
    vertex_task->Intialise(mesh_comp.vertex_buffer_id);
    task_scheduler->WaitForTask(delete_vertex_task_id);

    GetEngine()->MeshManager()->DeleteMesh(mesh_comp.mesh_id);
}