/*

---------------------------------------------------------------------------

Open Asset Import Library (assimp)

---------------------------------------------------------------------------

Copyright (c) 2006-2025, assimp team

All rights reserved.

Redistribution and use of this software in source and binary forms,

with or without modification, are permitted provided that the following

conditions are met:

* Redistributions of source code must retain the above

  copyright notice, this list of conditions and the

  following disclaimer.

* Redistributions in binary form must reproduce the above

  copyright notice, this list of conditions and the

  following disclaimer in the documentation and/or other

  materials provided with the distribution.

* Neither the name of the assimp team, nor the names of its

  contributors may be used to endorse or promote products

  derived from this software without specific prior

  written permission of the assimp team.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

---------------------------------------------------------------------------

*/

/** @file Implementation of the IrrMesh importer class */

#ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER

#include "IRRMeshLoader.h"

#include <assimp/ParsingUtils.h>

#include <assimp/fast_atof.h>

#include <assimp/importerdesc.h>

#include <assimp/material.h>

#include <assimp/mesh.h>

#include <assimp/scene.h>

#include <assimp/DefaultLogger.hpp>

#include <assimp/IOSystem.hpp>

#include <memory>

using namespace Assimp;

static constexpr aiImporterDesc desc = {

    "Irrlicht Mesh Reader",

    "",

    "",

    "http://irrlicht.sourceforge.net/",

    aiImporterFlags_SupportTextFlavour,

    0,

    0,

    0,

    0,

    "xml irrmesh"

};

// ------------------------------------------------------------------------------------------------

// Returns whether the class can handle the format of the given file.

bool IRRMeshImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {

    /* NOTE: A simple check for the file extension is not enough

     * here. Irrmesh and irr are easy, but xml is too generic

     * and could be collada, too. So we need to open the file and

     * search for typical tokens.

     */

    static const char *tokens[] = { "irrmesh" };

    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));

}

// ------------------------------------------------------------------------------------------------

// Get a list of all file extensions which are handled by this class

const aiImporterDesc *IRRMeshImporter::GetInfo() const {

    return &desc;

}

static void releaseMaterial(aiMaterial **mat) {

    if (*mat != nullptr) {

        delete *mat;

        *mat = nullptr;

    }

}

static void releaseMesh(aiMesh **mesh) {

    if (*mesh != nullptr) {

        delete *mesh;

        *mesh = nullptr;

    }

}

// ------------------------------------------------------------------------------------------------

// Imports the given file into the given scene structure.

void IRRMeshImporter::InternReadFile(const std::string &pFile,

        aiScene *pScene, IOSystem *pIOHandler) {

    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));

    // Check whether we can read from the file

    if (file == nullptr) {

        throw DeadlyImportError("Failed to open IRRMESH file ", pFile);

    }

    // Construct the irrXML parser

    XmlParser parser;

    if (!parser.parse(file.get())) {

        throw DeadlyImportError("XML parse error while loading IRRMESH file ", pFile);

    }

    XmlNode root = parser.getRootNode();

    // final data

    std::vector<aiMaterial *> materials;

    std::vector<aiMesh *> meshes;

    materials.reserve(5);

    meshes.reserve(5);

    // temporary data - current mesh buffer

    // TODO move all these to inside loop

    aiMaterial *curMat = nullptr;

    aiMesh *curMesh = nullptr;

    unsigned int curMatFlags = 0;

    std::vector<aiVector3D> curVertices, curNormals, curTangents, curBitangents;

    std::vector<aiColor4D> curColors;

    std::vector<aiVector3D> curUVs, curUV2s;

    // some temporary variables

    // textMeaning is a 15 year old variable, that could've been an enum

    // int textMeaning = 0; // 0=none? 1=vertices 2=indices

    // int vertexFormat = 0; // 0 = normal; 1 = 2 tcoords, 2 = tangents

    bool useColors = false;

    // irrmesh files have a top level <mesh> owning multiple <buffer> nodes.

    // Each <buffer> contains <material>, <vertices>, and <indices>

    // <material> tags here directly owns the material data specs

    // <vertices> are a vertex per line, contains position, UV1 coords, maybe UV2, normal, tangent, bitangent

    // <boundingbox> is ignored, I think assimp recalculates those?

    // Parse the XML file

    pugi::xml_node const &meshNode = root.child("mesh");

    for (pugi::xml_node bufferNode : meshNode.children()) {

        if (ASSIMP_stricmp(bufferNode.name(), "buffer")) {

            // Might be a useless warning

            ASSIMP_LOG_WARN("IRRMESH: Ignoring non buffer node <", bufferNode.name(), "> in mesh declaration");

            continue;

        }

        curMat = nullptr;

        curMesh = nullptr;

        curVertices.clear();

        curColors.clear();

        curNormals.clear();

        curUV2s.clear();

        curUVs.clear();

        curTangents.clear();

        curBitangents.clear();

        // TODO ensure all three nodes are present and populated

        // before allocating everything

        // Get first material node

        pugi::xml_node materialNode = bufferNode.child("material");

        if (materialNode) {

            curMat = ParseMaterial(materialNode, curMatFlags);

            // Warn if there's more materials

            if (materialNode.next_sibling("material")) {

                ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please");

            }

        } else {

            ASSIMP_LOG_ERROR("IRRMESH: Buffer must contain one material");

            continue;

        }

        // Get first vertices node

        pugi::xml_node verticesNode = bufferNode.child("vertices");

        if (verticesNode) {

            pugi::xml_attribute vertexCountAttrib = verticesNode.attribute("vertexCount");

            int vertexCount = vertexCountAttrib.as_int();

            if (vertexCount == 0) {

                // This is possible ... remove the mesh from the list and skip further reading

                ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices");

                releaseMaterial(&curMat);

                continue; // Bail out early

            };

            curVertices.reserve(vertexCount);

            curNormals.reserve(vertexCount);

            curColors.reserve(vertexCount);

            curUVs.reserve(vertexCount);

            VertexFormat vertexFormat;

            // Determine the file format

            pugi::xml_attribute typeAttrib = verticesNode.attribute("type");

            if (!ASSIMP_stricmp("2tcoords", typeAttrib.value())) {

                curUV2s.reserve(vertexCount);

                vertexFormat = VertexFormat::t2coord;

                if (curMatFlags & AI_IRRMESH_EXTRA_2ND_TEXTURE) {

                    // *********************************************************

                    // We have a second texture! So use this UV channel

                    // for it. The 2nd texture can be either a normal

                    // texture (solid_2layer or lightmap_xxx) or a normal

                    // map (normal_..., parallax_...)

                    // *********************************************************

                    int idx = 1;

                    aiMaterial *mat = (aiMaterial *)curMat;

                    if (curMatFlags & AI_IRRMESH_MAT_lightmap) {

                        mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_LIGHTMAP(0));

                    } else if (curMatFlags & AI_IRRMESH_MAT_normalmap_solid) {

                        mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0));

                    } else if (curMatFlags & AI_IRRMESH_MAT_solid_2layer) {

                        mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(1));

                    }

                }

            } else if (!ASSIMP_stricmp("tangents", typeAttrib.value())) {

                curTangents.reserve(vertexCount);

                curBitangents.reserve(vertexCount);

                vertexFormat = VertexFormat::tangent;

            } else if (!ASSIMP_stricmp("standard", typeAttrib.value())) {

                vertexFormat = VertexFormat::standard;

            } else {

                // Unsupported format, discard whole buffer/mesh

                // Assuming we have a correct material, then release it

                // We don't have a correct mesh for sure here

                releaseMaterial(&curMat);

                ASSIMP_LOG_ERROR("IRRMESH: Unknown vertex format");

                continue; // Skip rest of buffer

            };

            // We know what format buffer is, collect numbers

            std::string v = verticesNode.text().get();

            const char *end = v.c_str() + v.size();

            ParseBufferVertices(v.c_str(), end, vertexFormat,

                    curVertices, curNormals,

                    curTangents, curBitangents,

                    curUVs, curUV2s, curColors, useColors);

        }

        // Get indices

        // At this point we have some vertices and a valid material

        // Collect indices and create aiMesh at the same time

        pugi::xml_node indicesNode = bufferNode.child("indices");

        if (indicesNode) {

            // start a new mesh

            curMesh = new aiMesh();

            // allocate storage for all faces

            pugi::xml_attribute attr = indicesNode.attribute("indexCount");

            curMesh->mNumVertices = attr.as_int();

            if (!curMesh->mNumVertices) {

                // This is possible ... remove the mesh from the list and skip further reading

                ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices");

                // mesh - away

                releaseMesh(&curMesh);

                // material - away

                releaseMaterial(&curMat);

                continue; // Go to next buffer

            }

            if (curMesh->mNumVertices % 3) {

                ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3");

            }

            curMesh->mNumFaces = curMesh->mNumVertices / 3;

            curMesh->mFaces = new aiFace[curMesh->mNumFaces];

            // setup some members

            curMesh->mMaterialIndex = (unsigned int)materials.size();

            curMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;

            // allocate storage for all vertices

            curMesh->mVertices = new aiVector3D[curMesh->mNumVertices];

            if (curNormals.size() == curVertices.size()) {

                curMesh->mNormals = new aiVector3D[curMesh->mNumVertices];

            }

            if (curTangents.size() == curVertices.size()) {

                curMesh->mTangents = new aiVector3D[curMesh->mNumVertices];

            }

            if (curBitangents.size() == curVertices.size()) {

                curMesh->mBitangents = new aiVector3D[curMesh->mNumVertices];

            }

            if (curColors.size() == curVertices.size() && useColors) {

                curMesh->mColors[0] = new aiColor4D[curMesh->mNumVertices];

            }

            if (curUVs.size() == curVertices.size()) {

                curMesh->mTextureCoords[0] = new aiVector3D[curMesh->mNumVertices];

            }

            if (curUV2s.size() == curVertices.size()) {

                curMesh->mTextureCoords[1] = new aiVector3D[curMesh->mNumVertices];

            }

            // read indices

            aiFace *curFace = curMesh->mFaces;

            aiFace *const faceEnd = curMesh->mFaces + curMesh->mNumFaces;

            aiVector3D *pcV = curMesh->mVertices;

            aiVector3D *pcN = curMesh->mNormals;

            aiVector3D *pcT = curMesh->mTangents;

            aiVector3D *pcB = curMesh->mBitangents;

            aiColor4D *pcC0 = curMesh->mColors[0];

            aiVector3D *pcT0 = curMesh->mTextureCoords[0];

            aiVector3D *pcT1 = curMesh->mTextureCoords[1];

            unsigned int curIdx = 0;

            unsigned int total = 0;

            // NOTE this might explode for UTF-16 and wchars

            const char *sz = indicesNode.text().get();

            const char *end = sz + std::strlen(sz);

            // For each index loop over aiMesh faces

            while (SkipSpacesAndLineEnd(&sz, end)) {

                if (curFace >= faceEnd) {

                    ASSIMP_LOG_ERROR("IRRMESH: Too many indices");

                    break;

                }

                // if new face

                if (!curIdx) {

                    curFace->mNumIndices = 3;

                    curFace->mIndices = new unsigned int[3];

                }

                // Read index base 10

                // function advances the pointer

                unsigned int idx = strtoul10(sz, &sz);

                if (idx >= curVertices.size()) {

                    ASSIMP_LOG_ERROR("IRRMESH: Index out of range");

                    idx = 0;

                }

                // make up our own indices?

                curFace->mIndices[curIdx] = total++;

                // Copy over data to aiMesh

                *pcV++ = curVertices[idx];

                if (pcN)

                    *pcN++ = curNormals[idx];

                if (pcT)

                    *pcT++ = curTangents[idx];

                if (pcB)

                    *pcB++ = curBitangents[idx];

                if (pcC0)

                    *pcC0++ = curColors[idx];

                if (pcT0)

                    *pcT0++ = curUVs[idx];

                if (pcT1)

                    *pcT1++ = curUV2s[idx];

                // start new face

                if (++curIdx == 3) {

                    ++curFace;

                    curIdx = 0;

                }

            }

            // We should be at the end of mFaces

            if (curFace != faceEnd) {

                ASSIMP_LOG_ERROR("IRRMESH: Not enough indices");

            }

        }

        // Finish processing the mesh - do some small material workarounds

        if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) {

            // Take the opacity value of the current material

            // from the common vertex color alpha

            aiMaterial *mat = (aiMaterial *)curMat;

            mat->AddProperty(&curColors[0].a, 1, AI_MATKEY_OPACITY);

        }

        // end of previous buffer. A material and a mesh should be there

        if (!curMat || !curMesh) {

            ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");

            releaseMaterial(&curMat);

            releaseMesh(&curMesh);

        } else {

            materials.push_back(curMat);

            meshes.push_back(curMesh);

        }

    }

    // If one is empty then so is the other

    if (materials.empty() || meshes.empty()) {

        throw DeadlyImportError("IRRMESH: Unable to read a mesh from this file");

    }

    // now generate the output scene

    pScene->mNumMeshes = (unsigned int)meshes.size();

    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];

    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {

        pScene->mMeshes[i] = meshes[i];

        // clean this value ...

        pScene->mMeshes[i]->mNumUVComponents[3] = 0;

    }

    pScene->mNumMaterials = (unsigned int)materials.size();

    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];

    ::memcpy(pScene->mMaterials, &materials[0], sizeof(void *) * pScene->mNumMaterials);

    pScene->mRootNode = new aiNode();

    pScene->mRootNode->mName.Set("<IRRMesh>");

    pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;

    pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];

    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {

        pScene->mRootNode->mMeshes[i] = i;

    };

}

void IRRMeshImporter::ParseBufferVertices(const char *sz, const char *end, VertexFormat vertexFormat,

        std::vector<aiVector3D> &vertices, std::vector<aiVector3D> &normals,

        std::vector<aiVector3D> &tangents, std::vector<aiVector3D> &bitangents,

        std::vector<aiVector3D> &UVs, std::vector<aiVector3D> &UV2s,

        std::vector<aiColor4D> &colors, bool &useColors) {

    // read vertices

    do {

        SkipSpacesAndLineEnd(&sz, end);

        aiVector3D temp;

        aiColor4D c;

        // Read the vertex position

        sz = fast_atoreal_move(sz, temp.x);

        SkipSpaces(&sz, end);

        sz = fast_atoreal_move(sz, temp.y);

        SkipSpaces(&sz, end);

        sz = fast_atoreal_move(sz, temp.z);

        SkipSpaces(&sz, end);

        vertices.push_back(temp);

        // Read the vertex normals

        sz = fast_atoreal_move(sz, temp.x);

        SkipSpaces(&sz, end);

        sz = fast_atoreal_move(sz, temp.y);

        SkipSpaces(&sz, end);

        sz = fast_atoreal_move(sz, temp.z);

        SkipSpaces(&sz, end);

        normals.push_back(temp);

        // read the vertex colors

        uint32_t clr = strtoul16(sz, &sz);

        ColorFromARGBPacked(clr, c);

        // If we're pushing more than one distinct color

        if (!colors.empty() && c != *(colors.end() - 1))

            useColors = true;

        colors.push_back(c);

        SkipSpaces(&sz, end);

        // read the first UV coordinate set

        sz = fast_atoreal_move(sz, temp.x);

        SkipSpaces(&sz, end);

        sz = fast_atoreal_move(sz, temp.y);

        SkipSpaces(&sz, end);

        temp.z = 0.f;

        temp.y = 1.f - temp.y; // DX to OGL

        UVs.push_back(temp);

        // NOTE these correspond to specific S3DVertex* structs in irr sourcecode

        // So by definition, all buffers have either UV2 or tangents or neither

        // read the (optional) second UV coordinate set

        if (vertexFormat == VertexFormat::t2coord) {

            sz = fast_atoreal_move(sz, temp.x);

            SkipSpaces(&sz, end);

            sz = fast_atoreal_move(sz, temp.y);

            temp.y = 1.f - temp.y; // DX to OGL

            UV2s.push_back(temp);

        }

        // read optional tangent and bitangent vectors

        else if (vertexFormat == VertexFormat::tangent) {

            // tangents

            sz = fast_atoreal_move(sz, temp.x);

            SkipSpaces(&sz, end);

            sz = fast_atoreal_move(sz, temp.z);

            SkipSpaces(&sz, end);

            sz = fast_atoreal_move(sz, temp.y);

            SkipSpaces(&sz, end);

            temp.y *= -1.0f;

            tangents.push_back(temp);

            // bitangents

            sz = fast_atoreal_move(sz, temp.x);

            SkipSpaces(&sz, end);

            sz = fast_atoreal_move(sz, temp.z);

            SkipSpaces(&sz, end);

            sz = fast_atoreal_move(sz, temp.y);

            SkipSpaces(&sz, end);

            temp.y *= -1.0f;

            bitangents.push_back(temp);

        }

    } while (SkipLine(&sz, end));

    // IMPORTANT: We assume that each vertex is specified in one

    // line. So we can skip the rest of the line - unknown vertex

    // elements are ignored.

}

#endif // !! ASSIMP_BUILD_NO_IRRMESH_IMPORTER