#include "Geometry/Mesh.h"
#include "Geometry/Triangle.h"
#include "assimp/cimport.h"
#include "assimp/scene.h"
#include "assimp/postprocess.h"

mesh_entity_t mesh_load(const char* filename, uint8_t material_id, triangle_collection_t* triangles, material_collection_t* materials)
{
    mesh_entity_t entity = {0};

    const C_STRUCT aiScene* scene = aiImportFile(filename, aiProcessPreset_TargetRealtime_MaxQuality | aiProcess_GenSmoothNormals);
    if (scene == NULL)
    {
        perror(aiGetErrorString());
        return entity;
    }

    for (uint32_t i = 0; i < scene->mNumMeshes; i++)
    {
         struct aiMesh* mesh = scene->mMeshes[i];

        //TODO: Handle all primitive types, not just triangles
        if (mesh->mPrimitiveTypes != aiPrimitiveType_TRIANGLE)
        {
            continue;
        }

        for (uint32_t j = 0; j < mesh->mNumFaces; j++)
        {
             struct aiFace* face = &mesh->mFaces[j];
            if (face->mNumIndices != 3)
            {
                continue;
            }

            uint32_t index1 = face->mIndices[0];
            uint32_t index2 = face->mIndices[1];
            uint32_t index3 = face->mIndices[2];
                
            vec3s point1 = {
                mesh->mVertices[index1].x,
                mesh->mVertices[index1].y,
                mesh->mVertices[index1].z
            };
            vec3s point2 = {
                mesh->mVertices[index2].x,
                mesh->mVertices[index2].y,
                mesh->mVertices[index2].z
            };
            vec3s point3 = {
                mesh->mVertices[index3].x,
                mesh->mVertices[index3].y,
                mesh->mVertices[index3].z
            };

            vec3s normal1 = {
                mesh->mNormals[index1].x,
                mesh->mNormals[index1].y,
                mesh->mNormals[index1].z
            };
            vec3s normal2 = {
                mesh->mNormals[index2].x,
                mesh->mNormals[index2].y,
                mesh->mNormals[index2].z
            };
            vec3s normal3 = {
                mesh->mNormals[index3].x,
                mesh->mNormals[index3].y,
                mesh->mNormals[index3].z
            };

            //TODO: Handle materials, we use OpenPBR standard for parameter naming

            // uint32_t properties_count = scene->mMaterials[mesh->mMaterialIndex]->mNumProperties;
            // C_STRUCT aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
            // for (uint32_t p = 0; p < properties_count; p++)
            // {
            //     material->mProperties[p]->mKey;
            // }

            triangle_create_with_normals(point1, point2, point3, normal1, normal2, normal3, material_id, triangles);
        }
    }

    return entity;
}