MrUltimateLibrary Source

package eu.mrneznamy.mrultimatelibrary.holograms;

import eu.mrneznamy.mrultimatelibrary.holograms.providers.MrLibEntityHologramProvider;
import eu.mrneznamy.mrultimatelibrary.holograms.providers.MrLibTextDisplayHologramProvider;
import org.bukkit.inventory.ItemStack;
import eu.mrneznamy.mrultimatelibrary.utils.MrLibConsoleSayer;
import org.bukkit.Location;
import org.bukkit.Bukkit;
import org.bukkit.plugin.Plugin;
import org.bukkit.plugin.java.JavaPlugin;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * Centralized hologram manager for MrUltimateLibrary
 * Supports multiple hologram providers (DecentHolograms, CMI)
 */
public class MrLibHologramFacade {
    
    private static MrLibHologramFacade instance;
    private final Map<String, MrLibHologramProvider> providers = new HashMap<>();
    private MrLibHologramProvider activeProvider;
    private String preferredProvider = null;

    private MrLibHologramFacade() {
        setupProviders();
    }

    /**
     * Get the singleton instance of MrLibHologramFacade
     */
    public static MrLibHologramFacade getInstance() {
        if (instance == null) {
            instance = new MrLibHologramFacade();
        }
        return instance;
    }

    /**
     * Set the preferred hologram provider. This will re-initialize the provider selection.
     * @param providerName Name of the preferred provider (e.g., "MrUltimateLibrary-TextDisplay", "MrUltimateLibrary-Entity").
     */
    public void setPreferredProvider(String providerName) {
        this.preferredProvider = providerName;
        setupProviders();
    }

    /**
     * Setup available hologram providers
     */
    private void setupProviders() {
        
        Plugin MrUltimateLibraryPlugin = eu.mrneznamy.mrultimatelibrary.MrUltimateLibrary.getInstance();

        
        providers.clear();
        providers.put("MrUltimateLibrary-Entity", new MrLibEntityHologramProvider(MrUltimateLibraryPlugin));
        providers.put("MrUltimateLibrary-TextDisplay", new MrLibTextDisplayHologramProvider(MrUltimateLibraryPlugin));

        
        if (preferredProvider != null && !preferredProvider.isEmpty()) {
            MrLibHologramProvider preferred = providers.get(preferredProvider);
            if (preferred != null && preferred.isEnabled()) {
                activeProvider = preferred;
                MrLibConsoleSayer.MrSay_Success("Hologram support enabled: " + preferredProvider);
                return;
            } else {
                MrLibConsoleSayer.MrSay_Warning("Preferred hologram provider '" + preferredProvider + "' not available, trying alternatives...");
            }
        }

        
        MrLibHologramProvider textDisplayProvider = providers.get("MrUltimateLibrary-TextDisplay");
        if (textDisplayProvider != null && textDisplayProvider.isEnabled()) {
            activeProvider = textDisplayProvider;
            MrLibConsoleSayer.MrSay_Success("Hologram support enabled: MrUltimateLibrary-TextDisplay (auto-detected)");
            return;
        }

        MrLibHologramProvider entityProvider = providers.get("MrUltimateLibrary-Entity");
        if (entityProvider != null && entityProvider.isEnabled()) {
            activeProvider = entityProvider;
            MrLibConsoleSayer.MrSay_Success("Hologram support enabled: MrUltimateLibrary-Entity (fallback)");
            return;
        }

        activeProvider = null;
        MrLibConsoleSayer.MrSay_Warning("Hologram support disabled: No providers available");
    }
    
    /**
     * Set a specific provider as active
     * @param providerName Name of the provider (MrUltimateLibrary-TextDisplay, MrUltimateLibrary-Entity)
     * @return true if provider was set, false if not found or disabled
     */
    public boolean setProvider(String providerName) {
        MrLibHologramProvider provider = providers.get(providerName);
        if (provider != null && provider.isEnabled()) {
            activeProvider = provider;
            MrLibConsoleSayer.MrSay_Success("Hologram provider set to: " + providerName);
            return true;
        } else {
            MrLibConsoleSayer.MrSay_Warning("Failed to set hologram provider: " + providerName + " (not available)");
            return false;
        }
    }
    
    /**
     * Check if holograms are enabled
     * @return true if a hologram provider is available
     */
    public boolean isEnabled() {
        return activeProvider != null;
    }
    
    /**
     * Create a new hologram
     * @param name Unique name for the hologram
     * @param location Location where to create the hologram
     * @param lines List of lines to display
     */
    public void createHologram(String name, Location location, List<String> lines) {
        if (!isEnabled()) {
            return;
        }
        
        List<String> filteredLines = filterHologramLines(lines);
        
        try {
            Plugin p = eu.mrneznamy.mrultimatelibrary.MrUltimateLibrary.getInstance();
            boolean debug = p != null && p.getConfig().getBoolean("debug-holograms", false);
            if (debug) {
                String prov = activeProvider != null ? activeProvider.getProviderName() : "null";
                String world = location != null && location.getWorld() != null ? location.getWorld().getName() : "null";
                MrLibConsoleSayer.MrSay_Info("[Holograms-Facade] create name='" + name + "' provider=" + prov + " world=" + world + " loc=" + (location!=null?String.format("(%.2f, %.2f, %.2f)", location.getX(), location.getY(), location.getZ()):"null") + " lines=" + (filteredLines!=null?filteredLines.size():0));
            }
        } catch (Throwable ignored) {}
        activeProvider.createHologram(name, location, filteredLines);
    }
    
    /**
     * Update an existing hologram's lines
     * @param name Name of the hologram
     * @param lines New lines to display
     */
    public void updateHologram(String name, List<String> lines) {
        if (!isEnabled()) {
            return;
        }
        List<String> filteredLines = filterHologramLines(lines);
        try {
            Plugin p = eu.mrneznamy.mrultimatelibrary.MrUltimateLibrary.getInstance();
            boolean debug = p != null && p.getConfig().getBoolean("debug-holograms", false);
            if (debug) {
                String prov = activeProvider != null ? activeProvider.getProviderName() : "null";
                MrLibConsoleSayer.MrSay_Info("[Holograms-Facade] update name='" + name + "' provider=" + prov + " lines=" + (filteredLines!=null?filteredLines.size():0));
            }
        } catch (Throwable ignored) {}
        activeProvider.updateHologram(name, filteredLines);
    }
    
    /**
     * Delete a hologram
     * @param name Name of the hologram to delete
     */
    public void deleteHologram(String name) {
        if (!isEnabled()) {
            return;
        }
        try {
            Plugin p = eu.mrneznamy.mrultimatelibrary.MrUltimateLibrary.getInstance();
            boolean debug = p != null && p.getConfig().getBoolean("debug-holograms", false);
            if (debug) {
                String prov = activeProvider != null ? activeProvider.getProviderName() : "null";
                MrLibConsoleSayer.MrSay_Info("[Holograms-Facade] delete name='" + name + "' provider=" + prov);
            }
        } catch (Throwable ignored) {}
        activeProvider.deleteHologram(name);
    }
    
    /**
     * Cleanup all holograms (for server shutdown/restart)
     */
    public void cleanupAllHolograms() {
        try {
            Plugin p = eu.mrneznamy.mrultimatelibrary.MrUltimateLibrary.getInstance();
            boolean debug = p != null && p.getConfig().getBoolean("debug-holograms", false);
            if (debug) {
                MrLibConsoleSayer.MrSay_Info("[Holograms-Facade] cleanupAllHolograms invoked");
            }
        } catch (Throwable ignored) {}
        
        if (activeProvider instanceof MrLibEntityHologramProvider) {
            ((MrLibEntityHologramProvider) activeProvider).cleanupAllHolograms();
        } else if (activeProvider instanceof MrLibTextDisplayHologramProvider) {
            ((MrLibTextDisplayHologramProvider) activeProvider).cleanupAllHolograms();
        }
    }

    /**
     * Check if a hologram exists
     * @param name Name of the hologram
     * @return true if the hologram exists
     */
    public boolean hologramExists(String name) {
        if (!isEnabled()) {
            return false;
        }
        return activeProvider.hologramExists(name);
    }

    /**
     * Check if a hologram exists
     * @param name Name of the hologram
     * @return true if the hologram exists
     */
    public boolean has(String name) {
        if (!isEnabled()) {
            return false;
        }
        return activeProvider.hologramExists(name);
    }

    /**
     * Get the name of the current active provider
     * @return Provider name, or null if none active
     */
    public String getActiveProviderName() {
        if (activeProvider == null) {
            return null;
        }
        return activeProvider.getProviderName();
    }
    
    /**
     * Get the active provider
     * @return Active provider, or null if none active
     */
    public MrLibHologramProvider getActiveProvider() {
        return activeProvider;
    }
    
    /**
     * Get performance statistics for Entity Hologram provider
     * @return Performance stats string, or null if not using entity provider
     */
    public String getEntityHologramPerformanceStats() {
        if (activeProvider instanceof MrLibEntityHologramProvider) {
            return ((MrLibEntityHologramProvider) activeProvider).getPerformanceStats();
        }
        return null;
    }
    
    /**
     * Force update all entity holograms (for debugging)
     */
    public void forceUpdateAllEntityHolograms() {
        if (activeProvider instanceof MrLibEntityHologramProvider) {
            ((MrLibEntityHologramProvider) activeProvider).forceUpdateAll();
        }
    }
    
    /**
     * Check if currently using Entity Hologram provider
     * @return true if using optimized entity provider
     */
    public boolean isUsingEntityProvider() {
        return activeProvider instanceof MrLibEntityHologramProvider;
    }
    
    /**
     * Shutdown hologram manager (for plugin disable)
     */
    public void shutdown() {
        cleanupAllHolograms();
        
        if (activeProvider instanceof MrLibEntityHologramProvider) {
            ((MrLibEntityHologramProvider) activeProvider).shutdown();
        } else if (activeProvider instanceof MrLibTextDisplayHologramProvider) {
            ((MrLibTextDisplayHologramProvider) activeProvider).shutdown();
        }
        
        providers.clear();
        
        activeProvider = null;
        instance = null;
    }
    
    /**
     * Filter hologram lines to remove message tags
     * @param lines Original lines
     * @return Filtered lines with message tags removed
     */
    private List<String> filterHologramLines(List<String> lines) {
        if (lines == null) {
            return new ArrayList<>();
        }
        
        List<String> filteredLines = new ArrayList<>();
        for (String line : lines) {
            if (line != null) {
                String filteredLine = line.replaceAll("\\(!.*?\\)", "");
                filteredLines.add(filteredLine);
            }
        }
        return filteredLines;
    }
}