ModelEngineManager.java | API issue

package com.darkbladedev.integrations.modelengine;

import org.bukkit.Bukkit;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.plugin.Plugin;

import com.darkbladedev.AnimalsAndStuff;
import com.darkbladedev.utils.ColorText;
import com.ticxo.modelengine.api.ModelEngineAPI;
import com.ticxo.modelengine.api.model.ActiveModel;
import com.ticxo.modelengine.api.model.ModeledEntity;

import java.util.HashMap;
import java.util.Map;
import java.util.logging.Level;

public class ModelEngineManager {

    private final AnimalsAndStuff plugin;
    private boolean modelEngineEnabled = false;
    private ModelEngineAPI modelEngineAPI;
    private Map<String, String> mobModelMap = new HashMap<>();
    private String modelId;

    public ModelEngineManager(AnimalsAndStuff plugin) {
        this.plugin = plugin;
        this.initialize();
    }

    public void initialize() {
        // Verificar si ModelEngine está presente
        Plugin modelEngine = Bukkit.getPluginManager().getPlugin("ModelEngine");
        if (modelEngine != null && modelEngine.isEnabled()) {
            modelEngineEnabled = true;
            Bukkit.getConsoleSender().sendMessage(ColorText.Colorize("&aModelEngine detected! Enabling model features."));

            // Cargar configuración de modelos
            loadModelConfiguration();

            // Intentar obtener la API de ModelEngine
            try {
                this.modelEngineAPI = ModelEngineAPI.getAPI(); // HERE IS THE API INITIALIZATION TRY

                Bukkit.getConsoleSender().sendMessage(ColorText.Colorize("&aModelEngine connection established successfully."));
            } catch (Exception e) {
                plugin.getLogger().log(Level.WARNING, "Error on MEG connection task", e);
                modelEngineEnabled = false;
            }
        } else {
            Bukkit.getConsoleSender().sendMessage(ColorText.Colorize("&cModelEngine not detected. 3D models are not available now."));
        }
    }

    private void loadModelConfiguration() {
        if (plugin.getConfig().contains("models.mobs")) {
            for (String mobKey : plugin.getConfig().getConfigurationSection("models.mobs").getKeys(false)) {
                String modelId = plugin.getConfig().getString("models.mobs." + mobKey);
                if (modelId != null && !modelId.isEmpty()) {
                    mobModelMap.put(mobKey, modelId);
                    Bukkit.getConsoleSender().sendMessage(ColorText.Colorize("&aModel loaded for " + mobKey + ": " + modelId));
                }
            }
        }
    }

    /**
     * Aplica un modelo 3D a una entidad si ModelEngine está disponible
     * @param entity La entidad a la que aplicar el modelo
     * @param mobKey La clave del mob personalizado
     * @return true si se aplicó el modelo, false en caso contrario
     */
    public boolean applyModel(LivingEntity entity, String mobKey) {
        if (!modelEngineEnabled || modelEngineAPI == null) {
            plugin.getLogger().severe("ModelEngine not enabled/loaded, Model application process failed."); // HERE IS THE ERROR MESSAGE
            return false;
        }

        // Verificar si hay un modelo configurado para este mob
        String modelId = mobModelMap.get(mobKey);
        if (modelId == null || modelId.isEmpty()) {
            plugin.getLogger().log(Level.SEVERE, mobKey + " model not found. Skipping model application.");
            return false;
        }

        plugin.getLogger().info("Applying model (" + modelId + ") to " + mobKey);

        try {
            // Crear un ActiveModel
            ModeledEntity modeledEntity = ModelEngineAPI.createModeledEntity(entity);

            ActiveModel activeModel = ModelEngineAPI.createActiveModel(modelId);

            // Aplicar el modelo a la entidad
            modeledEntity.addModel(activeModel, true);

            return true;
        } catch (Exception e) {
            plugin.getLogger().log(Level.WARNING, "Error applying model to " + mobKey, e);
            return false;
        }
    }

    /**
     * Elimina el modelo 3D de una entidad
     * @param entity La entidad de la que eliminar el modelo
     */
    public void removeModel(Entity entity) {
        if (!modelEngineEnabled || modelEngineAPI == null) {
            plugin.getLogger().severe("ModelEngine not enabled/loaded, Model remove process failed.");
            return;
        }

        try {
            for (String mobKey : plugin.getConfig().getConfigurationSection("models.mobs").getKeys(false)) {
                modelId = plugin.getConfig().getString("models.mobs." + mobKey);

                // Eliminar el modelo directamente usando la API
                ModeledEntity modeledEntity = ModelEngineAPI.getModeledEntity(entity.getUniqueId());
                modeledEntity.removeModel(getModelForMob(modelId));
            }
        } catch (Exception e) {
            plugin.getLogger().log(Level.WARNING, "Error removing model", e);
        }
    }

    /**
     * Verifica si ModelEngine está habilitado
     * @return true si ModelEngine está habilitado, false en caso contrario
     */
    public boolean isModelEngineEnabled() {
        return modelEngineEnabled;
    }

    /**
     * Obtiene el ID del modelo para un mob específico
     * @param mobKey La clave del mob
     * @return El ID del modelo, o null si no hay ninguno configurado
     */
    public String getModelForMob(String mobKey) {
        return mobModelMap.get(mobKey);
    }
}