#include "CGL430Model.h"
#include "CEngine.h"
#include "CWindowManager.h"
#include "CResourcesManager.h"
#include "COpenGL430Renderer.h"
#include "CConVarManager.h"

CGL430ModelLoadingContext::CGL430ModelLoadingContext(CResource* _current_resource, const std::filesystem::path& _path) : CModelLoadingContext(_current_resource, _path) { }

CGL430Model::CGL430Model()
{
    auto& callback = GetLoadPipelineSetupCallback();
    if(callback.IsEmpty())
    {
        callback += [](CLoadPipeline& pipeline)
        {
            pipeline.push_back //build model data for gpu (async)
            (
                {
                    [](std::shared_ptr<CLoadingContext> context) -> bool
                    {
                        auto mdlContext = std::dynamic_pointer_cast<CGL430ModelLoadingContext>(context);
                        auto thisResource = dynamic_cast<CGL430Model*>(context->CurrentResource);

                        std::map<std::tuple<uint64_t, uint64_t, uint64_t, int>, unsigned int> vertexMap;
                        unsigned int currentIndex = 0;

                        for (const auto& tri : mdlContext->LoadInfo.Triangles)
                        {
                            for (int i = 0; i < 3; i++)
                            {
                                uint64_t vIdx = tri.VertexIndex[i];
                                uint64_t nIdx = tri.NormalIndex[i];
                                uint64_t tIdx = tri.UvIndex[i];

                                auto key = std::make_tuple(vIdx, nIdx, tIdx, tri.MaterialIndex);
                                auto it = vertexMap.find(key);

                                if (it == vertexMap.end())
                                {
                                    const auto& v = mdlContext->LoadInfo.Vertices[vIdx];
                                    CGL430ModelLoadingContext::PackedVertex pv;
                                    pv.Position = v.Position;
                                    pv.Normal = (nIdx < mdlContext->LoadInfo.Normals.size()) ? mdlContext->LoadInfo.Normals[nIdx] : glm::vec3(0);
                                    pv.TexCoord = (tIdx < mdlContext->LoadInfo.UvCoords.size()) ? mdlContext->LoadInfo.UvCoords[tIdx] : glm::vec2(0);

                                    int count = std::min<int>(v.Bones.size(), 4);
                                    for (int j = 0; j < count; j++)
                                    {
                                        pv.BoneIds[j] = v.Bones[j].BoneIndex;
                                        pv.BoneWeights[j] = v.Bones[j].Weight;
                                    }

                                    mdlContext->vertexBuffer.push_back(pv);
                                    mdlContext->indexBuffer.push_back(currentIndex);
                                    vertexMap[key] = currentIndex++;
                                }
                                else
                                {
                                    mdlContext->indexBuffer.push_back(it->second);
                                }
                            }
                        }

                        mdlContext->indexCount = mdlContext->indexBuffer.size();
                        thisResource->indexCount = mdlContext->indexCount;

                        auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
                        auto winman = CEngine::GetInstance()->Components.GetComponentTyped<CWindowManager>();
                        auto& _renderer = winman->Renderer;
                        auto renderer = dynamic_cast<COpenGL430Renderer*>(_renderer.get());

                        for(auto& res : context->RequiredResources)
                        {
                            if(res && res->GetType() == renderer->GetMaterialType())
                            {
                                //res->Wait(); NO WAITING IN ASYNC THREAD
                                auto material = std::dynamic_pointer_cast<CGL430Material>(res);
                                thisResource->UsedMaterials.push_back(material);
                            }
                        }

                        mdlContext->materialPerTriangle.reserve(mdlContext->LoadInfo.Triangles.size());
                        for (const auto& tri : mdlContext->LoadInfo.Triangles)
                        {
                            std::string matName = mdlContext->LoadInfo.MaterialsList.at(tri.MaterialIndex);
                            auto it = std::find_if(thisResource->UsedMaterials.begin(), thisResource->UsedMaterials.end(), [&matName](auto mat) -> bool
                            {
                                return mat->Name == matName;
                            });

                            int id = renderer->GetMaterialIndex(it->get());
                            mdlContext->materialPerTriangle.push_back(id);
                        }
                        return true;
                    },
                    true //async (is_async)
                }
            );

            pipeline.push_back //upload model data to gpu (sync)
            (
                {
                    [](std::shared_ptr<CLoadingContext> context) -> bool
                    {
                        auto mdlContext = std::dynamic_pointer_cast<CGL430ModelLoadingContext>(context);
                        auto thisResource = dynamic_cast<CGL430Model*>(context->CurrentResource);

                        using PackedVertex = CGL430ModelLoadingContext::PackedVertex;

                        glGenVertexArrays(1, &thisResource->vao);
                        glBindVertexArray(thisResource->vao);

                        glGenBuffers(1, &thisResource->vbo);
                        glBindBuffer(GL_ARRAY_BUFFER, thisResource->vbo);
                        glBufferData(GL_ARRAY_BUFFER, mdlContext->vertexBuffer.size() * sizeof(PackedVertex), mdlContext->vertexBuffer.data(), GL_STATIC_DRAW);

                        glGenBuffers(1, &thisResource->ebo);
                        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, thisResource->ebo);
                        glBufferData(GL_ELEMENT_ARRAY_BUFFER, mdlContext->indexBuffer.size() * sizeof(unsigned int), mdlContext->indexBuffer.data(), GL_STATIC_DRAW);

                        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), (void*)offsetof(PackedVertex, Position));
                        glEnableVertexAttribArray(0);
                        glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), (void*)offsetof(PackedVertex, Normal));
                        glEnableVertexAttribArray(1);
                        glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), (void*)offsetof(PackedVertex, TexCoord));
                        glEnableVertexAttribArray(2);
                        glVertexAttribIPointer(3, 4, GL_INT, sizeof(PackedVertex), (void*)offsetof(PackedVertex, BoneIds));
                        glEnableVertexAttribArray(3);
                        glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), (void*)offsetof(PackedVertex, BoneWeights));
                        glEnableVertexAttribArray(4);
                        
                        glBindVertexArray(0);

                        glGenBuffers(1, &thisResource->materialSSBO);
                        glBindBuffer(GL_SHADER_STORAGE_BUFFER, thisResource->materialSSBO);
                        glBufferData(GL_SHADER_STORAGE_BUFFER, mdlContext->materialPerTriangle.size() * sizeof(int), mdlContext->materialPerTriangle.data(), GL_STATIC_DRAW);
                        glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, thisResource->materialSSBO); //TODO change binding
                        glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
                        return true;
                    },
                    false //sync (is_async)
                }
            );
        };
    }
}

int CGL430Model::LoadMaterial(const std::string& name)
{
    std::string materialName = std::filesystem::path(name).stem().string();

    auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
    auto winman = CEngine::GetInstance()->Components.GetComponentTyped<CWindowManager>();
    auto& _renderer = winman->Renderer;
    auto renderer = dynamic_cast<COpenGL430Renderer*>(_renderer.get());

    auto it = std::find_if(UsedMaterials.begin(), UsedMaterials.end(), [&materialName](auto mat) -> bool
    {
        return mat->Name == materialName;
    });

    if(it != UsedMaterials.end()) { return renderer->GetMaterialIndex(it->get()); }

    auto _material = resman->GetOrCreate(renderer->GetMaterialType(), name);

    if(!_material)
    {
        Log::ErrInstance() << "Can't load material " << name << "\n";
    }

    auto material = std::dynamic_pointer_cast<CGL430Material>(_material);
    UsedMaterials.push_back(material);

    int ret = renderer->GetMaterialIndex(material.get());
    return ret;
}

void CGL430Model::V_Load(const CModelLoadInfo& loadinfo)
{
    if(!CEngine::GetInstance()->Components.IsComponentPresent<CWindowManager>()) { return; }

    struct PackedVertex
    {
        glm::vec3 Position;
        glm::vec3 Normal;
        glm::vec2 TexCoord;
        glm::ivec4 BoneIds = { 0, 0, 0, 0 };
        glm::vec4 BoneWeights = { 0.0f, 0.0f, 0.0f, 0.0f };
    };

    std::vector<PackedVertex> vertexBuffer;
    std::vector<unsigned int> indexBuffer;

    std::map<std::tuple<uint64_t, uint64_t, uint64_t, int>, unsigned int> vertexMap;
    unsigned int currentIndex = 0;

    for (const auto& tri : loadinfo.Triangles)
    {
        for (int i = 0; i < 3; i++)
        {
            uint64_t vIdx = tri.VertexIndex[i];
            uint64_t nIdx = tri.NormalIndex[i];
            uint64_t tIdx = tri.UvIndex[i];

            auto key = std::make_tuple(vIdx, nIdx, tIdx, tri.MaterialIndex);
            auto it = vertexMap.find(key);

            if (it == vertexMap.end())
            {
                const auto& v = loadinfo.Vertices[vIdx];
                PackedVertex pv;
                pv.Position = v.Position;
                pv.Normal = (nIdx < loadinfo.Normals.size()) ? loadinfo.Normals[nIdx] : glm::vec3(0);
                pv.TexCoord = (tIdx < loadinfo.UvCoords.size()) ? loadinfo.UvCoords[tIdx] : glm::vec2(0);

                int count = std::min<int>(v.Bones.size(), 4);
                for (int j = 0; j < count; j++)
                {
                    pv.BoneIds[j] = v.Bones[j].BoneIndex;
                    pv.BoneWeights[j] = v.Bones[j].Weight;
                }

                vertexBuffer.push_back(pv);
                indexBuffer.push_back(currentIndex);
                vertexMap[key] = currentIndex++;
            }
            else
            {
                indexBuffer.push_back(it->second);
            }
        }
    }

    indexCount = indexBuffer.size();

    Log::Instance() << "Model indexCount is " << indexCount << "\n";

    glGenVertexArrays(1, &vao);
    glBindVertexArray(vao);

    glGenBuffers(1, &vbo);
    glBindBuffer(GL_ARRAY_BUFFER, vbo);
    glBufferData(GL_ARRAY_BUFFER, vertexBuffer.size() * sizeof(PackedVertex), vertexBuffer.data(), GL_STATIC_DRAW);

    glGenBuffers(1, &ebo);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, indexBuffer.size() * sizeof(unsigned int), indexBuffer.data(), GL_STATIC_DRAW);

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), (void*)offsetof(PackedVertex, Position));
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), (void*)offsetof(PackedVertex, Normal));
    glEnableVertexAttribArray(1);
    glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), (void*)offsetof(PackedVertex, TexCoord));
    glEnableVertexAttribArray(2);
    glVertexAttribIPointer(3, 4, GL_INT, sizeof(PackedVertex), (void*)offsetof(PackedVertex, BoneIds));
    glEnableVertexAttribArray(3);
    glVertexAttribPointer(4, 4, GL_FLOAT, GL_FALSE, sizeof(PackedVertex), (void*)offsetof(PackedVertex, BoneWeights));
    glEnableVertexAttribArray(4);
    
    glBindVertexArray(0);

    std::vector<int> materialPerTriangle;
    materialPerTriangle.reserve(loadinfo.Triangles.size());

    for (const auto& tri : loadinfo.Triangles)
    {
        int id = LoadMaterial(loadinfo.MaterialsList.at(tri.MaterialIndex) + ".emtl");
        materialPerTriangle.push_back(id);
    }

    glGenBuffers(1, &materialSSBO);
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, materialSSBO);
    glBufferData(GL_SHADER_STORAGE_BUFFER, materialPerTriangle.size() * sizeof(int), materialPerTriangle.data(), GL_STATIC_DRAW);
    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, materialSSBO); //TODO change binding
    glBindBuffer(GL_SHADER_STORAGE_BUFFER, 0);
}

std::shared_ptr<CLoadingContext> CGL430Model::CreatePipelineContext(const std::filesystem::path& path)
{
    return std::make_shared<CGL430ModelLoadingContext>(this, path);
}

void CGL430Model::V_Draw()
{
    auto resman = CEngine::GetInstance()->Components.GetComponentTyped<CResourcesManager>();
    auto winman = CEngine::GetInstance()->Components.GetComponentTyped<CWindowManager>();
    auto& _renderer = winman->Renderer;
    auto renderer = dynamic_cast<COpenGL430Renderer*>(_renderer.get());

    //renderer->S_Default.Bind(); //TODO unnecessary binding

    glBindBufferBase(GL_SHADER_STORAGE_BUFFER, 2, materialSSBO);
    renderer->BindMaterialsSSBO();

    glBindVertexArray(vao);
    glDrawElements(GL_TRIANGLES, indexCount, GL_UNSIGNED_INT, 0);
    glBindVertexArray(0);

    //Log::Instance() << "drawn\n";
}

void CGL430Model::Unload() //TODO RAII
{
    if (ebo)
    {
        glDeleteBuffers(1, &ebo);
        ebo = 0;
    }

    if (vbo)
    {
        glDeleteBuffers(1, &vbo);
        vbo = 0;
    }

    if (vao)
    {
        glDeleteVertexArrays(1, &vao);
        vao = 0;
    }

    if (materialSSBO)
    {
        glDeleteBuffers(1, &materialSSBO);
        materialSSBO = 0;
    }

    if (bonesSSBO)
    {
        glDeleteBuffers(1, &bonesSSBO);
        bonesSSBO = 0;
    }

    indexCount = 0;
}

CGL430Model::~CGL430Model()
{
    Unload();
}

LINK_RESOURCE_TO_CLASS(CGL430Model, gl430model);