//
#include "HydraActorManager.h"
#include "../actor/HydraActor.h"
#include "../engine/HydraEngine.h"
#include "../ecs/HydraEntityManager.h"
#include "../ecs/HydraECS.h"
#include "../ecs/components/HydraPositionComponent.h"
#include "../ecs/components/HydraPhysicsComponent.h"
#include "../ecs/systems/HydraTransformSystem.h"
#include "../ecs/systems/HydraPhysicsSystem.h"
#include "../fileaccess/HydraGLTFLoader.h"
#include "../task/actor/HydraLoadGLTFFileTask.hpp"
#include "../scheduler/HydraTaskScheduler.h"
#include <stdio.h>

HydraActor *const HydraActorManager::GetActor(HydraID actorID)
{
    if (actorID < MAX_ACTORS)
    {
        return m_actors[actorID];
    }
    return nullptr;
}

std::vector<HydraID> &HydraActorManager::GetChildren(HydraID actor_id)
{
    return m_actors[actor_id]->m_children;
}

void HydraActorManager::DeleteActor(HydraID actorID)
{    
    assert(actorID <= m_actors.size() && "DeleteActor::INVALID ACTOR ID");
    //std::lock_guard<std::mutex> lock(m_mutex);
    if(m_actors[actorID] != nullptr)
    {
        
        GetEngine()->ECS()->DestroyEntity(actorID);
        _SetActorDeleted(actorID);
    }
    
}

void HydraActorManager::_SetActorDeleted(HydraID actorID)
{
    if (m_actors[actorID] != nullptr)
    {
        delete m_actors[actorID];
    }
    m_actors[actorID] = nullptr;
    m_available_actor_ids.push_back(actorID);
}


HydraID HydraActorManager::LoadActor(std::string filename)
{
    HydraID actor_id = INVALID_HYDRA_ID;
    HydraTaskScheduler* task_scheduler = GetEngine()->TaskScheduler();
    HydraID load_task_id = task_scheduler->CreateTask<HydraLoadGLTFFileTask>(HydraThreadAffinity::Render);
    HydraLoadGLTFFileTask* load_task = static_cast<HydraLoadGLTFFileTask*>(task_scheduler->GetTask(load_task_id));
    load_task->Initialise(filename, &actor_id);
    task_scheduler->WaitForTask(load_task_id);
    return actor_id;
}


HydraID HydraActorManager::_SaveActor(HydraActor *actor)
{
    HydraECS *ecs = GetEngine()->ECS();

    if (m_available_actor_ids.size() > 0)
    {
        HydraID id = m_available_actor_ids.front();
        m_available_actor_ids.pop_front();
        actor->m_id = id;
        m_actors[id] = actor;

        return id;
    }
    delete actor;
    return INVALID_HYDRA_ID;
}

void HydraActorManager::Initialise(size_t max_actors)
{
    m_max_actors = max_actors;
    std::lock_guard<std::mutex> lock(m_mutex);

    m_actors.resize(max_actors);
  
    for (int i = 0; i < max_actors; i++)
    {
        m_available_actor_ids.push_back(i);
    }
}



void HydraActorManager::FixedTickActor(float actor_id, float delta_t)
{
    HydraActor *actor = GetActor(actor_id);
    if (actor != nullptr)
    {
        actor->FixedTick(delta_t);
    }

}
void HydraActorManager::InitialiseActor(HydraID actorID)
{
    HydraActor *actor = GetActor(actorID);
    if (actor != nullptr)
    {
         actor->InitialiseComponents();
        m_actors_waiting_for_init.push_back(actorID);
    }
}

void HydraActorManager::Shutdown()
{
    std::lock_guard<std::mutex> lock(m_mutex);
    // for (HydraID actor_id = 0; actor_id < MAX_ACTORS; actor_id++)
    // {
    //     if (m_actors[actor_id] != nullptr)
    //     {
    //         HydraActor *actor = m_actors[actor_id];

    //         m_actors[actor_id]->m_status = HydraActorStatus::WAITING_FOR_DELETE;
    //         _RemoveActorFromTickFixed(actor_id);
    //         _RemoveActorFromWaiting(actor_id);
    //         actor->Destroy();
    //         // for (int i = 0; i < m_actors[actor_id]->m_component_types.size(); i++)
    //         // {
    //         //     GetEngine()->ComponentManager()->DeleteComponent(m_actors[actor_id]->m_component_types[i], actor_id);
    //         // }

    //         // HydraID delete_task_id = GetEngine()->TaskScheduler()->CreateTask<HydraDeleteActorTask>(HydraThreadAffinity::General);
    //         // HydraDeleteActorTask *task = (HydraDeleteActorTask *)GetEngine()->TaskScheduler()->GetTask(delete_task_id);
    //         // task->Initialise(actor_id);
    //         // GetEngine()->TaskScheduler()->WaitForTask(delete_task_id);
    //     }
    //     _SetActorDeleted(actor_id);
    // }
}

void HydraActorManager::RotateActor(HydraID actorID, float euler_x, float euler_y, float euler_z)
{
    HydraECS *ecs = GetEngine()->ECS();

    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);

    pos_comp.orientation[0] += euler_x;
    pos_comp.orientation[1] += euler_y;
    pos_comp.orientation[2] += euler_z;
    pos_comp.needs_update = true;
    ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID);
}


void HydraActorManager::SetPosition(HydraID actorID, glm::dvec3 position)
{
    HydraECS *ecs = GetEngine()->ECS();

    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
    pos_comp.position = position;
    
    if(!pos_comp.needs_update)
    {
        ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID);
    }
}

void HydraActorManager::SetOrientation(HydraID actorID, float x, float y, float z)
{
    HydraECS *ecs = GetEngine()->ECS();
    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
    pos_comp.orientation = glm::vec3(x, y, z);
    if(!pos_comp.needs_update)
    {
        ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID);
    }
}

void HydraActorManager::SetLinearVelocity(HydraID actor_id, glm::vec3 velocity)
{
    HydraECS* ecs = GetEngine()->ECS();
    if (ecs->HasComponent<HydraPhysicsComponent>(actor_id))
    {
        std::shared_ptr<HydraPhysicsSystem> phys_sys = ecs->GetSystem<HydraPhysicsSystem>();
        phys_sys->SetLinearVelocity(actor_id, velocity);
    }
}

void HydraActorManager::SetPositionAndOrientation(HydraID actorID, glm::dvec3 position, glm::vec3 euler_angles, bool ignore_physics)
{
    HydraECS *ecs = GetEngine()->ECS();
    if(ecs->HasComponent<HydraPositionComponent>(actorID))
    {
        HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
        pos_comp.position = position;
        pos_comp.orientation = glm::vec3(euler_angles.x,euler_angles.y,euler_angles.z);
        
        if(!pos_comp.needs_update)
        {
            ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID, ignore_physics);
        }
    }
    else
    {
        std::cout << "HERE";
    }

}

void HydraActorManager::SetScale(HydraID actor_id, glm::dvec3 scaling)
{
     HydraECS *ecs = GetEngine()->ECS();
    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actor_id);
    pos_comp.scale = glm::vec3(scaling);
    

    // if (ecs->HasComponent<HydraECSPhysicsComponent>(actorID))
    // {
    //     HydraECSPhysicsComponent &phys_comp = ecs->GetComponent<HydraECSPhysicsComponent>(actorID);
    //     phys_comp.physics_definition.pose = GetActorPose(actorID);
    // }
        if(!pos_comp.needs_update)
    {
    ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actor_id);
    }
}

void HydraActorManager::SetRelationship(HydraID parent_id, HydraID child_id)
{
    HydraActor *parent_actor = GetActor(parent_id);
    HydraActor *child_actor = GetActor(child_id);
    child_actor->m_parent_id = parent_id;
    parent_actor->m_children.push_back(child_id);
}

void HydraActorManager::TranslateActor(HydraID actorID, glm::dvec3 translation)
{
    HydraECS *ecs = GetEngine()->ECS();

    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);

    pos_comp.position = pos_comp.position + translation;
    

    // if (ecs->HasComponent<HydraECSPhysicsComponent>(actorID))
    // {
    //     HydraECSPhysicsComponent &phys_comp = ecs->GetComponent<HydraECSPhysicsComponent>(actorID);
    //     // const float*  matrix = glm::value_ptr<float>(GetActorPose(actorID));

    //     // std::copy(matrix, matrix + 16, phys_comp.physics_definition.pose);
    //     phys_comp.physics_definition.pose = GetActorPose(actorID);
    // }
    ecs->GetSystem<HydraTransformSystem>()->UpdateTransform(actorID);
}



glm::mat4 HydraActorManager::GetActorPose(HydraID actorID)
{

    HydraPositionComponent &pos = GetEngine()->ECS()->GetComponent<HydraPositionComponent>(actorID);
    glm::mat4 model_matrix = pos.transform;
    if (pos.needs_update)
    {
        glm::mat4 trans_matrix = glm::translate(pos.position);
        glm::mat4 rot_matrix = glm::toMat4(glm::quat(pos.orientation));
        model_matrix = trans_matrix * rot_matrix;
    }
    return model_matrix;
}

glm::vec3 HydraActorManager::GetActorOrientation(HydraID actorID)
{
    HydraECS *ecs = GetEngine()->ECS();
    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
    return pos_comp.orientation;
}

glm::vec3 HydraActorManager::GetActorVelocity(HydraID actorID)
{
    
    return glm::dvec3(0, 0, 0);
}
glm::dvec3 HydraActorManager::GetActorPosition(HydraID actorID)
{
    HydraECS *ecs = GetEngine()->ECS();
    HydraPositionComponent &pos_comp = ecs->GetComponent<HydraPositionComponent>(actorID);
        
    return pos_comp.position;
}


HydraID HydraActorManager::GetParent(HydraID actor_id)
{
    return m_actors[actor_id]->m_parent_id;
}

HydraID HydraActorManager::GetRoot(HydraID actor_id)
{
    HydraID parent_id = GetParent(actor_id);
    if(parent_id == INVALID_HYDRA_ID)
    {
        return actor_id;
    }
    return GetRoot(parent_id);
}