#options GAME (IW3, IW4, IW5, T5, T6)

#filename "Game/" + GAME + "/XModel/XModelDumper" + GAME + ".cpp"

#set DUMPER_HEADER "\"XModelDumper" + GAME + ".h\""
#set COMMON_HEADER "\"Game/" + GAME + "/Common" + GAME + ".h\""
#set JSON_HEADER "\"Game/" + GAME + "/XModel/JsonXModel" + GAME + ".h\""

#if GAME == "IW3"
#define FEATURE_IW3
#define GAME_LOWER "iw3"
#elif GAME == "IW4"
#define FEATURE_IW4
#define GAME_LOWER "iw4"
#elif GAME == "IW5"
#define FEATURE_IW5
#define GAME_LOWER "iw5"
#elif GAME == "T5"
#define FEATURE_T5
#define GAME_LOWER "t5"
#elif GAME == "T6"
#define FEATURE_T6
#define GAME_LOWER "t6"
#endif

// This file was templated.
// See XModelDumper.cpp.template.
// Do not modify, changes will be lost.

#include DUMPER_HEADER

#include COMMON_HEADER
#include JSON_HEADER

#include "ObjWriting.h"
#include "Utils/DistinctMapper.h"
#include "Utils/QuatInt16.h"
#include "XModel/Export/XModelBinWriter.h"
#include "XModel/Export/XModelExportWriter.h"
#include "XModel/Gltf/GltfBinOutput.h"
#include "XModel/Gltf/GltfTextOutput.h"
#include "XModel/Gltf/GltfWriter.h"
#include "XModel/Obj/ObjWriter.h"
#include "XModel/XModelWriter.h"

#include <cassert>
#include <format>

using namespace GAME;

#set CLASS_NAME "Dumper" + GAME

namespace
{
    std::string GetFileNameForLod(const std::string& modelName, const unsigned lod, const std::string& extension)
    {
        return std::format("model_export/{}_lod{}{}", modelName, lod, extension);
    }

    GfxImage* GetImageFromTextureDef(const MaterialTextureDef& textureDef)
    {
#ifdef FEATURE_T6
        return textureDef.image;
#else
        return textureDef.u.image;
#endif
    }

    GfxImage* GetMaterialColorMap(const Material* material)
    {
        std::vector<MaterialTextureDef*> potentialTextureDefs;

        for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++)
        {
            MaterialTextureDef* def = &material->textureTable[textureIndex];

#if defined(FEATURE_IW3) || defined(FEATURE_IW4) || defined(FEATURE_IW5)
            if (def->semantic == TS_COLOR_MAP)
                potentialTextureDefs.push_back(def);
#else
            if (def->semantic == TS_COLOR_MAP || def->semantic >= TS_COLOR0_MAP && def->semantic <= TS_COLOR15_MAP)
                potentialTextureDefs.push_back(def);
#endif
        }

        if (potentialTextureDefs.empty())
            return nullptr;
        if (potentialTextureDefs.size() == 1)
            return GetImageFromTextureDef(*potentialTextureDefs[0]);

        for (const auto* def : potentialTextureDefs)
        {
            if (tolower(def->nameStart) == 'c' && tolower(def->nameEnd) == 'p')
                return GetImageFromTextureDef(*def);
        }

        for (const auto* def : potentialTextureDefs)
        {
            if (tolower(def->nameStart) == 'r' && tolower(def->nameEnd) == 'k')
                return GetImageFromTextureDef(*def);
        }

        for (const auto* def : potentialTextureDefs)
        {
            if (tolower(def->nameStart) == 'd' && tolower(def->nameEnd) == 'p')
                return GetImageFromTextureDef(*def);
        }

        return GetImageFromTextureDef(*potentialTextureDefs[0]);
    }

    GfxImage* GetMaterialNormalMap(const Material* material)
    {
        std::vector<MaterialTextureDef*> potentialTextureDefs;

        for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++)
        {
            MaterialTextureDef* def = &material->textureTable[textureIndex];

            if (def->semantic == TS_NORMAL_MAP)
                potentialTextureDefs.push_back(def);
        }

        if (potentialTextureDefs.empty())
            return nullptr;
        if (potentialTextureDefs.size() == 1)
            return GetImageFromTextureDef(*potentialTextureDefs[0]);

        for (const auto* def : potentialTextureDefs)
        {
            if (def->nameStart == 'n' && def->nameEnd == 'p')
                return GetImageFromTextureDef(*def);
        }

        return GetImageFromTextureDef(*potentialTextureDefs[0]);
    }

    GfxImage* GetMaterialSpecularMap(const Material* material)
    {
        std::vector<MaterialTextureDef*> potentialTextureDefs;

        for (auto textureIndex = 0u; textureIndex < material->textureCount; textureIndex++)
        {
            MaterialTextureDef* def = &material->textureTable[textureIndex];

            if (def->semantic == TS_SPECULAR_MAP)
                potentialTextureDefs.push_back(def);
        }

        if (potentialTextureDefs.empty())
            return nullptr;
        if (potentialTextureDefs.size() == 1)
            return GetImageFromTextureDef(*potentialTextureDefs[0]);

        for (const auto* def : potentialTextureDefs)
        {
            if (def->nameStart == 's' && def->nameEnd == 'p')
                return GetImageFromTextureDef(*def);
        }

        return GetImageFromTextureDef(*potentialTextureDefs[0]);
    }

    bool GetSurfaces(const XModel* model, const unsigned lod, XSurface*& surfs, unsigned& surfCount)
    {
#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
        if (!model->lodInfo[lod].modelSurfs || !model->lodInfo[lod].modelSurfs->surfs)
            return false;

        surfs = model->lodInfo[lod].modelSurfs->surfs;
        surfCount = model->lodInfo[lod].modelSurfs->numsurfs;
#else
        if (!model->surfs)
            return false;

        surfs = &model->surfs[model->lodInfo[lod].surfIndex];
        surfCount = model->lodInfo[lod].numsurfs;
#endif

        return true;
    }

    bool HasDefaultArmature(const XModel* model, const unsigned lod)
    {
        if (model->numRootBones != 1 || model->numBones != 1)
            return false;

        XSurface* surfs;
        unsigned surfCount;
        if (!GetSurfaces(model, lod, surfs, surfCount))
            return true;

        for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++)
        {
            const auto& surface = surfs[surfIndex];

            if (surface.vertListCount != 1 || surface.vertInfo.vertsBlend)
                return false;

            const auto& vertList = surface.vertList[0];
            if (vertList.boneOffset != 0 || vertList.triOffset != 0 || vertList.triCount != surface.triCount || vertList.vertCount != surface.vertCount)
                return false;
        }

        return true;
    }

    void OmitDefaultArmature(XModelCommon& common)
    {
        common.m_bones.clear();
        common.m_bone_weight_data.weights.clear();
        common.m_vertex_bone_weights.resize(common.m_vertices.size());
        for (auto& vertexWeights : common.m_vertex_bone_weights)
        {
            vertexWeights.weightOffset = 0u;
            vertexWeights.weightCount = 0u;
        }
    }

    void AddXModelBones(XModelCommon& out, const AssetDumpingContext& context, const XModel* model)
    {
        for (auto boneNum = 0u; boneNum < model->numBones; boneNum++)
        {
            XModelBone bone;
            if (model->boneNames[boneNum] < context.m_zone.m_script_strings.Count())
                bone.name = context.m_zone.m_script_strings[model->boneNames[boneNum]];
            else
                bone.name = "INVALID_BONE_NAME";

            if (boneNum >= model->numRootBones)
                bone.parentIndex = static_cast<int>(boneNum - static_cast<unsigned int>(model->parentList[boneNum - model->numRootBones]));
            else
                bone.parentIndex = std::nullopt;

            bone.scale[0] = 1.0f;
            bone.scale[1] = 1.0f;
            bone.scale[2] = 1.0f;

            const auto& baseMat = model->baseMat[boneNum];
            bone.globalOffset[0] = baseMat.trans.x;
            bone.globalOffset[1] = baseMat.trans.y;
            bone.globalOffset[2] = baseMat.trans.z;
            bone.globalRotation = {
                .x = baseMat.quat.x,
                .y = baseMat.quat.y,
                .z = baseMat.quat.z,
                .w = baseMat.quat.w,
            };

            if (boneNum < model->numRootBones)
            {
                bone.localOffset[0] = 0;
                bone.localOffset[1] = 0;
                bone.localOffset[2] = 0;
                bone.localRotation = {.x = 0, .y = 0, .z = 0, .w = 1};
            }
            else
            {
                const auto* trans = &model->trans[(boneNum - model->numRootBones) * 3];
                bone.localOffset[0] = trans[0];
                bone.localOffset[1] = trans[1];
                bone.localOffset[2] = trans[2];

                const auto& quat = model->quats[boneNum - model->numRootBones];
                bone.localRotation = {
                    .x = QuatInt16::ToFloat(quat.v[0]),
                    .y = QuatInt16::ToFloat(quat.v[1]),
                    .z = QuatInt16::ToFloat(quat.v[2]),
                    .w = QuatInt16::ToFloat(quat.v[3]),
                };
            }

            out.m_bones.emplace_back(std::move(bone));
        }
    }

    const char* AssetName(const char* input)
    {
        if (input && input[0] == ',')
            return &input[1];

        return input;
    }

    void AddXModelMaterials(XModelCommon& out, DistinctMapper<Material*>& materialMapper, const XModel* model)
    {
        for (auto surfaceMaterialNum = 0u; surfaceMaterialNum < model->numsurfs; surfaceMaterialNum++)
        {
            Material* material = model->materialHandles[surfaceMaterialNum];
            if (materialMapper.Add(material))
            {
                XModelMaterial xMaterial;
                xMaterial.ApplyDefaults();

                xMaterial.name = AssetName(material->info.name);
                const auto* colorMap = GetMaterialColorMap(material);
                if (colorMap)
                    xMaterial.colorMapName = AssetName(colorMap->name);

                const auto* normalMap = GetMaterialNormalMap(material);
                if (normalMap)
                    xMaterial.normalMapName = AssetName(normalMap->name);

                const auto* specularMap = GetMaterialSpecularMap(material);
                if (specularMap)
                    xMaterial.specularMapName = AssetName(specularMap->name);

                out.m_materials.emplace_back(std::move(xMaterial));
            }
        }
    }

    void AddXModelObjects(XModelCommon& out, const XModel* model, const unsigned lod, const DistinctMapper<Material*>& materialMapper)
    {
        const auto surfCount = model->lodInfo[lod].numsurfs;
        const auto baseSurfaceIndex = model->lodInfo[lod].surfIndex;

        for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++)
        {
            XModelObject object;
            object.name = std::format("surf{}", surfIndex);
            object.materialIndex = static_cast<int>(materialMapper.GetDistinctPositionByInputPosition(surfIndex + baseSurfaceIndex));

            out.m_objects.emplace_back(std::move(object));
        }
    }

    void AddXModelVertices(XModelCommon& out, const XModel* model, const unsigned lod)
    {
        XSurface* surfs;
        unsigned surfCount;
        if (!GetSurfaces(model, lod, surfs, surfCount))
            return;

        for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++)
        {
            const auto& surface = surfs[surfIndex];

            for (auto vertexIndex = 0u; vertexIndex < surface.vertCount; vertexIndex++)
            {
                const auto& v = surface.verts0[vertexIndex];

                XModelVertex vertex{};
                vertex.coordinates[0] = v.xyz.x;
                vertex.coordinates[1] = v.xyz.y;
                vertex.coordinates[2] = v.xyz.z;
                Common::Vec3UnpackUnitVec(v.normal, vertex.normal);
                Common::Vec4UnpackGfxColor(v.color, vertex.color);
                Common::Vec2UnpackTexCoords(v.texCoord, vertex.uv);

                out.m_vertices.emplace_back(vertex);
            }
        }
    }

    void AllocateXModelBoneWeights(const XModel* model, const unsigned lod, XModelVertexBoneWeightCollection& weightCollection)
    {
        XSurface* surfs;
        unsigned surfCount;
        if (!GetSurfaces(model, lod, surfs, surfCount))
            return;

        auto totalWeightCount = 0u;
        for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++)
        {
            const auto& surface = surfs[surfIndex];

            if (surface.vertList)
            {
                totalWeightCount += surface.vertListCount;
            }

            if (surface.vertInfo.vertsBlend)
            {
                totalWeightCount += surface.vertInfo.vertCount[0] * 1;
                totalWeightCount += surface.vertInfo.vertCount[1] * 2;
                totalWeightCount += surface.vertInfo.vertCount[2] * 3;
                totalWeightCount += surface.vertInfo.vertCount[3] * 4;
            }
        }

        weightCollection.weights.resize(totalWeightCount);
    }

    float BoneWeight16(const uint16_t value)
    {
        return static_cast<float>(value) / static_cast<float>(std::numeric_limits<uint16_t>::max());
    }

    void AddXModelVertexBoneWeights(XModelCommon& out, const XModel* model, const unsigned lod)
    {
        XSurface* surfs;
        unsigned surfCount;
        if (!GetSurfaces(model, lod, surfs, surfCount))
            return;

        auto& weightCollection = out.m_bone_weight_data;
        auto weightOffset = 0u;

        for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++)
        {
            const auto& surface = surfs[surfIndex];
            auto handledVertices = 0u;

            if (surface.vertList)
            {
                for (auto vertListIndex = 0u; vertListIndex < surface.vertListCount; vertListIndex++)
                {
                    const auto& vertList = surface.vertList[vertListIndex];
                    const auto boneWeightOffset = weightOffset;
                    
                    weightCollection.weights[weightOffset++] = 
                        XModelBoneWeight{.boneIndex = static_cast<unsigned>(vertList.boneOffset / sizeof(DObjSkelMat)), .weight = 1.0f};

                    for (auto vertListVertexOffset = 0u; vertListVertexOffset < vertList.vertCount; vertListVertexOffset++)
                    {
                        out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 1);
                    }
                    handledVertices += vertList.vertCount;
                }
            }

            auto vertsBlendOffset = 0u;
            if (surface.vertInfo.vertsBlend)
            {
                // 1 bone weight
                for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[0]; vertIndex++)
                {
                    const auto boneWeightOffset = weightOffset;
                    const unsigned boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat);
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex0, .weight = 1.0f};

                    vertsBlendOffset += 1;

                    out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 1);
                }

                // 2 bone weights
                for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[1]; vertIndex++)
                {
                    const auto boneWeightOffset = weightOffset;
                    const unsigned boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat);
                    const unsigned boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat);
                    const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]);
                    const auto boneWeight0 = 1.0f - boneWeight1;
                    
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex0, .weight = boneWeight0};
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex1, .weight = boneWeight1};

                    vertsBlendOffset += 3;

                    out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 2);
                }

                // 3 bone weights
                for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[2]; vertIndex++)
                {
                    const auto boneWeightOffset = weightOffset;
                    const unsigned boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat);
                    const unsigned boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat);
                    const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]);
                    const unsigned boneIndex2 = surface.vertInfo.vertsBlend[vertsBlendOffset + 3] / sizeof(DObjSkelMat);
                    const auto boneWeight2 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 4]);
                    const auto boneWeight0 = 1.0f - boneWeight1 - boneWeight2;
                    
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex0, .weight = boneWeight0};
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex1, .weight = boneWeight1};
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex2, .weight = boneWeight2};

                    vertsBlendOffset += 5;

                    out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 3);
                }

                // 4 bone weights
                for (auto vertIndex = 0; vertIndex < surface.vertInfo.vertCount[3]; vertIndex++)
                {
                    const auto boneWeightOffset = weightOffset;
                    const unsigned boneIndex0 = surface.vertInfo.vertsBlend[vertsBlendOffset + 0] / sizeof(DObjSkelMat);
                    const unsigned boneIndex1 = surface.vertInfo.vertsBlend[vertsBlendOffset + 1] / sizeof(DObjSkelMat);
                    const auto boneWeight1 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 2]);
                    const unsigned boneIndex2 = surface.vertInfo.vertsBlend[vertsBlendOffset + 3] / sizeof(DObjSkelMat);
                    const auto boneWeight2 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 4]);
                    const unsigned boneIndex3 = surface.vertInfo.vertsBlend[vertsBlendOffset + 5] / sizeof(DObjSkelMat);
                    const auto boneWeight3 = BoneWeight16(surface.vertInfo.vertsBlend[vertsBlendOffset + 6]);
                    const auto boneWeight0 = 1.0f - boneWeight1 - boneWeight2 - boneWeight3;
                    
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex0, .weight = boneWeight0};
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex1, .weight = boneWeight1};
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex2, .weight = boneWeight2};
                    weightCollection.weights[weightOffset++] = XModelBoneWeight{.boneIndex = boneIndex3, .weight = boneWeight3};

                    vertsBlendOffset += 7;

                    out.m_vertex_bone_weights.emplace_back(boneWeightOffset, 4);
                }

                handledVertices +=
                    surface.vertInfo.vertCount[0] + surface.vertInfo.vertCount[1] + surface.vertInfo.vertCount[2] + surface.vertInfo.vertCount[3];
            }

            for (; handledVertices < surface.vertCount; handledVertices++)
            {
                out.m_vertex_bone_weights.emplace_back(0, 0);
            }
        }
    }

    void AddXModelFaces(XModelCommon& out, const XModel* model, const unsigned lod)
    {
        XSurface* surfs;
        unsigned surfCount;
        if (!GetSurfaces(model, lod, surfs, surfCount))
            return;

        for (auto surfIndex = 0u; surfIndex < surfCount; surfIndex++)
        {
            const auto& surface = surfs[surfIndex];
            auto& object = out.m_objects[surfIndex];
            object.m_faces.reserve(surface.triCount);

            for (auto triIndex = 0u; triIndex < surface.triCount; triIndex++)
            {
                const auto& tri = surface.triIndices[triIndex];

                XModelFace face{};
                face.vertexIndex[0] = tri.i[0] + surface.baseVertIndex;
                face.vertexIndex[1] = tri.i[1] + surface.baseVertIndex;
                face.vertexIndex[2] = tri.i[2] + surface.baseVertIndex;
                object.m_faces.emplace_back(face);
            }
        }
    }

    bool CanOmitDefaultArmature()
    {
        return ObjWriting::Configuration.ModelOutputFormat != ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_EXPORT
               && ObjWriting::Configuration.ModelOutputFormat != ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_BIN;
    }

    void PopulateXModelWriter(XModelCommon& out, const AssetDumpingContext& context, const unsigned lod, const XModel* model)
    {
        DistinctMapper<Material*> materialMapper(model->numsurfs);
        AllocateXModelBoneWeights(model, lod, out.m_bone_weight_data);

        out.m_name = std::format("{}_lod{}", model->name, lod);
        AddXModelMaterials(out, materialMapper, model);
        AddXModelObjects(out, model, lod, materialMapper);
        AddXModelVertices(out, model, lod);
        AddXModelFaces(out, model, lod);
        
        if (!CanOmitDefaultArmature() || !HasDefaultArmature(model, lod))
        {
            AddXModelBones(out, context, model);
            AddXModelVertexBoneWeights(out, model, lod);
        }
        else
        {
            OmitDefaultArmature(out);
        }
    }

    void DumpObjMtl(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo<XModel>& asset)
    {
        const auto* model = asset.Asset();
        const auto mtlFile = context.OpenAssetFile(std::format("model_export/{}.mtl", model->name));

        if (!mtlFile)
            return;

        const auto* game = IGame::GetGameById(context.m_zone.m_game_id);
        const auto writer = obj::CreateMtlWriter(*mtlFile, game->GetShortName(), context.m_zone.m_name);
        DistinctMapper<Material*> materialMapper(model->numsurfs);

        writer->Write(common);
    }

    void DumpObjLod(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo<XModel>& asset, const unsigned lod)
    {
        const auto* model = asset.Asset();
        const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, ".obj"));

        if (!assetFile)
            return;

        const auto* game = IGame::GetGameById(context.m_zone.m_game_id);
        const auto writer =
            obj::CreateObjWriter(*assetFile, std::format("{}.mtl", model->name), game->GetShortName(), context.m_zone.m_name);
        DistinctMapper<Material*> materialMapper(model->numsurfs);

        writer->Write(common);
    }

    void DumpXModelExportLod(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo<XModel>& asset, const unsigned lod)
    {
        const auto* model = asset.Asset();
        const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, ".xmodel_export"));

        if (!assetFile)
            return;

        const auto* game = IGame::GetGameById(context.m_zone.m_game_id);
        const auto writer = xmodel_export::CreateWriterForVersion6(*assetFile, game->GetShortName(), context.m_zone.m_name);
        writer->Write(common);
    }

    void DumpXModelBinLod(const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo<XModel>& asset, const unsigned lod)
    {
        const auto* model = asset.Asset();
        const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, ".xmodel_bin"));

        if (!assetFile)
            return;

        const auto* game = IGame::GetGameById(context.m_zone.m_game_id);
        const auto writer = xmodel_bin::CreateWriterForVersion7(*assetFile, game->GetShortName(), context.m_zone.m_name);
        writer->Write(common);
    }

    template<typename T>
    void DumpGltfLod(
        const XModelCommon& common, const AssetDumpingContext& context, const XAssetInfo<XModel>& asset, const unsigned lod, const std::string& extension)
    {
        const auto* model = asset.Asset();
        const auto assetFile = context.OpenAssetFile(GetFileNameForLod(model->name, lod, extension));

        if (!assetFile)
            return;

        const auto* game = IGame::GetGameById(context.m_zone.m_game_id);
        const auto output = std::make_unique<T>(*assetFile);
        const auto writer = gltf::Writer::CreateWriter(output.get(), game->GetShortName(), context.m_zone.m_name);

        writer->Write(common);
    }

    void DumpXModelSurfs(const AssetDumpingContext& context, const XAssetInfo<XModel>& asset)
    {
        const auto* model = asset.Asset();

        for (auto currentLod = 0u; currentLod < model->numLods; currentLod++)
        {
            XModelCommon common;
            PopulateXModelWriter(common, context, currentLod, asset.Asset());

            switch (ObjWriting::Configuration.ModelOutputFormat)
            {
            case ObjWriting::Configuration_t::ModelOutputFormat_e::OBJ:
                DumpObjLod(common, context, asset, currentLod);
                if (currentLod == 0u)
                    DumpObjMtl(common, context, asset);
                break;

            case ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_EXPORT:
                DumpXModelExportLod(common, context, asset, currentLod);
                break;

            case ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_BIN:
                DumpXModelBinLod(common, context, asset, currentLod);
                break;

            case ObjWriting::Configuration_t::ModelOutputFormat_e::GLTF:
                DumpGltfLod<gltf::TextOutput>(common, context, asset, currentLod, ".gltf");
                break;

            case ObjWriting::Configuration_t::ModelOutputFormat_e::GLB:
                DumpGltfLod<gltf::BinOutput>(common, context, asset, currentLod, ".glb");
                break;

            default:
                assert(false);
                break;
            }
        }
    }

    class JsonDumper
    {
    public:
        JsonDumper(AssetDumpingContext& context, std::ostream& stream)
            : m_stream(stream)
        {
        }

        void Dump(const XModel* xmodel) const
        {
            JsonXModel jsonXModel;
            CreateJsonXModel(jsonXModel, *xmodel);
            nlohmann::json jRoot = jsonXModel;

            jRoot["$schema"] = "http://openassettools.dev/schema/xmodel.v1.json";
            jRoot["_type"] = "xmodel";
            jRoot["_version"] = 2;
            jRoot["_game"] = GAME_LOWER;

            m_stream << std::setw(4) << jRoot << "\n";
        }

    private:
        static const char* AssetName(const char* input)
        {
            if (input && input[0] == ',')
                return &input[1];

            return input;
        }

        static const char* GetExtensionForModelByConfig()
        {
            switch (ObjWriting::Configuration.ModelOutputFormat)
            {
            case ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_EXPORT:
                return ".xmodel_export";
            case ObjWriting::Configuration_t::ModelOutputFormat_e::XMODEL_BIN:
                return ".xmodel_bin";
            case ObjWriting::Configuration_t::ModelOutputFormat_e::OBJ:
                return ".obj";
            case ObjWriting::Configuration_t::ModelOutputFormat_e::GLTF:
                return ".gltf";
            case ObjWriting::Configuration_t::ModelOutputFormat_e::GLB:
                return ".glb";
            default:
                assert(false);
                return "";
            }
        }

        static bool IsAnimated(const XModel& xmodel)
        {
#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
            for (auto i = 0u; i < xmodel.numLods; i++)
            {
                const auto& lod = xmodel.lodInfo[i];
                if (lod.modelSurfs == nullptr || lod.modelSurfs->surfs == nullptr)
                    continue;

                for (auto j = 0u; j < lod.modelSurfs->numsurfs; j++)
                {
                    const auto& surf = xmodel.lodInfo[i].modelSurfs->surfs[j];
                    if (surf.vertInfo.vertsBlend)
                        return true;
                }
            }
#else
            for (auto i = 0u; i < xmodel.numsurfs; i++)
            {
                const auto& surf = xmodel.surfs[i];
                if (surf.vertInfo.vertsBlend)
                    return true;
            }
#endif

            return false;
        }

        static bool HasNulledTrans(const XModel& xmodel)
        {
            if (xmodel.trans == nullptr)
                return true;

            const auto transCount = (xmodel.numBones - xmodel.numRootBones) * 3u;
            for (auto i = 0u; i < transCount; i++)
            {
                if (xmodel.trans[i] != 0)
                    return false;
            }

            return true;
        }

        static bool HasNonNullBoneInfoTrans(const XModel& xmodel)
        {
            if (xmodel.boneInfo == nullptr)
                return false;

            for (auto i = 0u; i < xmodel.numBones; i++)
            {
                const auto& boneInfo = xmodel.boneInfo[i];
#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
                if (boneInfo.bounds.midPoint.x != 0 || boneInfo.bounds.midPoint.y != 0 || boneInfo.bounds.midPoint.z != 0)
                    return true;
#else
                if (boneInfo.offset.x != 0 || boneInfo.offset.y != 0 || boneInfo.offset.z != 0)
                    return true;
#endif
            }

            return false;
        }

        static JsonXModelType GetType(const XModel& xmodel)
        {
            if (!IsAnimated(xmodel))
                return JsonXModelType::RIGID;

            if (HasNulledTrans(xmodel) && HasNonNullBoneInfoTrans(xmodel))
                return JsonXModelType::VIEWHANDS;

            return JsonXModelType::ANIMATED;
        }

        static void CreateJsonXModel(JsonXModel& jXModel, const XModel& xmodel)
        {
            if (xmodel.collLod >= 0)
                jXModel.collLod = xmodel.collLod;

            jXModel.type = GetType(xmodel);

            for (auto lodNumber = 0u; lodNumber < xmodel.numLods; lodNumber++)
            {
                JsonXModelLod lod;
                lod.file = std::format("model_export/{}_lod{}{}", xmodel.name, lodNumber, GetExtensionForModelByConfig());
                lod.distance = xmodel.lodInfo[lodNumber].dist;

                jXModel.lods.emplace_back(std::move(lod));
            }

            if (xmodel.physPreset && xmodel.physPreset->name)
                jXModel.physPreset = AssetName(xmodel.physPreset->name);

#if defined(FEATURE_IW4) || defined(FEATURE_IW5)
            if (xmodel.physCollmap && xmodel.physCollmap->name)
                jXModel.physCollmap = AssetName(xmodel.physCollmap->name);
#endif

#if defined(FEATURE_T5) || defined(FEATURE_T6)
            if (xmodel.physConstraints && xmodel.physConstraints->name)
                jXModel.physConstraints = AssetName(xmodel.physConstraints->name);
#endif

            jXModel.flags = xmodel.flags;

#ifdef FEATURE_T6
            jXModel.lightingOriginOffset.x = xmodel.lightingOriginOffset.x;
            jXModel.lightingOriginOffset.y = xmodel.lightingOriginOffset.y;
            jXModel.lightingOriginOffset.z = xmodel.lightingOriginOffset.z;
            jXModel.lightingOriginRange = xmodel.lightingOriginRange;
#endif
        }

        std::ostream& m_stream;
    };

    void DumpXModelJson(AssetDumpingContext& context, const XAssetInfo<XModel>& asset)
    {
        const auto assetFile = context.OpenAssetFile(xmodel::GetJsonFileNameForAssetName(asset.m_name));
        if (!assetFile)
            return;

        const JsonDumper dumper(context, *assetFile);
        dumper.Dump(asset.Asset());
    }
} // namespace

namespace xmodel
{
    CLASS_NAME::CLASS_NAME (const AssetPool<GAME::AssetXModel::Type>& pool)
        : AbstractAssetDumper(pool)
    {
    }

    void CLASS_NAME::DumpAsset(AssetDumpingContext& context, const XAssetInfo<AssetXModel::Type>& asset)
    {
        DumpXModelJson(context, asset);
        DumpXModelSurfs(context, asset);
    }
}
