MrUltimateLibrary Source

package eu.mrneznamy.mrultimatelibrary.economy;

import eu.mrneznamy.mrultimatelibrary.utils.MrLibConsoleSayer;
import org.bukkit.Bukkit;
import org.bukkit.entity.Player;
import org.bukkit.plugin.RegisteredServiceProvider;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.server.ServiceRegisterEvent;

/**
 * Centralized Vault economy manager for all MrLib plugins
 * This allows all plugins to share one Vault integration instead of each having their own
 */
public class MrLibVaultManager implements Listener {
    
    private static MrLibVaultManager instance;
    private MrLibEconomyProvider economy;
    private boolean enabled = false;
    
    private MrLibVaultManager() {
        setupEconomy();
        
        org.bukkit.plugin.Plugin plugin = eu.mrneznamy.mrultimatelibrary.MrUltimateLibrary.getInstance();
        if (plugin != null) {
            Bukkit.getPluginManager().registerEvents(this, plugin);
        }
    }
    
    /**
     * Get the singleton instance of MrLibVaultManager
     */
    public static MrLibVaultManager getInstance() {
        if (instance == null) {
            instance = new MrLibVaultManager();
        }
        return instance;
    }

    @EventHandler
    public void onServiceRegister(ServiceRegisterEvent event) {
        if (enabled) return;

        
        String className = event.getProvider().getService().getName();
        if (className.equals("net.milkbowl.vault.economy.Economy") || 
            className.equals("net.milkbowl.vault2.economy.Economy")) {
            
            MrLibConsoleSayer.MrSay_Info("Economy service registered late: " + className + ". Retrying setup...");
            setupEconomy();
        }
    }
    
    /**
     * Setup Vault economy integration
     */
    private void setupEconomy() {
        if (Bukkit.getPluginManager().getPlugin("Vault") == null && Bukkit.getPluginManager().getPlugin("VaultUnlocked") == null) {
            MrLibConsoleSayer.MrSay_Warning("Vault or VaultUnlocked not found! Economy features will be disabled.");
            return;
        }

        
        try {
            Class<?> clazz = Class.forName("net.milkbowl.vault2.economy.Economy");
            RegisteredServiceProvider<?> rsp = Bukkit.getServicesManager().getRegistration(clazz);
            if (rsp != null) {
                economy = new VaultUnlockedEconomy(rsp.getProvider());
                enabled = true;
                MrLibConsoleSayer.MrSay_Success("VaultUnlocked (v2) economy integration enabled!");
                return;
            }
        } catch (ClassNotFoundException | NoClassDefFoundError ignored) {
            
        }
        
        
        
        try {
            RegisteredServiceProvider<net.milkbowl.vault.economy.Economy> rsp = Bukkit.getServicesManager().getRegistration(net.milkbowl.vault.economy.Economy.class);
            if (rsp != null) {
                economy = new VaultEconomy(rsp.getProvider());
                enabled = true;
                MrLibConsoleSayer.MrSay_Success("Vault (v1) economy integration enabled!");
                return;
            }
        } catch (NoClassDefFoundError ignored) {}

        MrLibConsoleSayer.MrSay_Warning("No economy provider found! Economy features will be disabled.");
    }

    private interface MrLibEconomyProvider {
        double getBalance(org.bukkit.OfflinePlayer player);
        boolean has(org.bukkit.OfflinePlayer player, double amount);
        boolean withdraw(org.bukkit.OfflinePlayer player, double amount);
        boolean deposit(org.bukkit.OfflinePlayer player, double amount);
        String format(double amount);
        Object getProvider();
    }

    private static class VaultEconomy implements MrLibEconomyProvider {
        private final net.milkbowl.vault.economy.Economy econ;
        public VaultEconomy(net.milkbowl.vault.economy.Economy econ) { this.econ = econ; }
        @Override public double getBalance(org.bukkit.OfflinePlayer player) { return econ.getBalance(player); }
        @Override public boolean has(org.bukkit.OfflinePlayer player, double amount) { return econ.has(player, amount); }
        @Override public boolean withdraw(org.bukkit.OfflinePlayer player, double amount) { return econ.withdrawPlayer(player, amount).transactionSuccess(); }
        @Override public boolean deposit(org.bukkit.OfflinePlayer player, double amount) { return econ.depositPlayer(player, amount).transactionSuccess(); }
        @Override public String format(double amount) { return econ.format(amount); }
        @Override public Object getProvider() { return econ; }
    }

    private static class VaultUnlockedEconomy implements MrLibEconomyProvider {
        private final Object econ;
        private java.lang.reflect.Method getBalanceMethod;
        private java.lang.reflect.Method hasMethod;
        private java.lang.reflect.Method withdrawMethod;
        private java.lang.reflect.Method depositMethod;
        private java.lang.reflect.Method formatMethod;
        private java.lang.reflect.Method responseSuccessMethod;
        private boolean useUUID = false;

        public VaultUnlockedEconomy(Object econ) {
            this.econ = econ;
            try {
                Class<?> clazz = econ.getClass();
                
                
                try {
                    getBalanceMethod = clazz.getMethod("getBalance", java.util.UUID.class);
                    useUUID = true;
                } catch (NoSuchMethodException e) {
                    try {
                        getBalanceMethod = clazz.getMethod("getBalance", org.bukkit.OfflinePlayer.class);
                    } catch (NoSuchMethodException ex) {
                        getBalanceMethod = clazz.getMethod("getBalance", String.class);
                    }
                }

                if (useUUID) {
                    hasMethod = clazz.getMethod("has", java.util.UUID.class, java.math.BigDecimal.class);
                    withdrawMethod = clazz.getMethod("withdraw", java.util.UUID.class, java.math.BigDecimal.class);
                    depositMethod = clazz.getMethod("deposit", java.util.UUID.class, java.math.BigDecimal.class);
                } else {
                    Class<?> paramType = getBalanceMethod.getParameterTypes()[0];
                    hasMethod = clazz.getMethod("has", paramType, java.math.BigDecimal.class);
                    withdrawMethod = clazz.getMethod("withdraw", paramType, java.math.BigDecimal.class);
                    depositMethod = clazz.getMethod("deposit", paramType, java.math.BigDecimal.class);
                }
                
                formatMethod = clazz.getMethod("format", java.math.BigDecimal.class);
                
                
                Class<?> responseClass = withdrawMethod.getReturnType();
                try {
                    responseSuccessMethod = responseClass.getMethod("isSuccess");
                } catch (NoSuchMethodException e) {
                    responseSuccessMethod = responseClass.getMethod("transactionSuccess");
                }
            } catch (Exception e) {
                MrLibConsoleSayer.MrSay_Error("Failed to initialize VaultUnlocked reflection: " + e.getMessage());
                e.printStackTrace();
            }
        }

        @Override
        public double getBalance(org.bukkit.OfflinePlayer player) {
            try {
                Object param = useUUID ? player.getUniqueId() : (getBalanceMethod.getParameterTypes()[0] == String.class ? player.getName() : player);
                Object result = getBalanceMethod.invoke(econ, param);
                if (result instanceof java.math.BigDecimal) {
                    return ((java.math.BigDecimal) result).doubleValue();
                }
                return (double) result;
            } catch (Exception e) {
                return 0.0;
            }
        }

        @Override
        public boolean has(org.bukkit.OfflinePlayer player, double amount) {
            try {
                Object param = useUUID ? player.getUniqueId() : (hasMethod.getParameterTypes()[0] == String.class ? player.getName() : player);
                return (boolean) hasMethod.invoke(econ, param, java.math.BigDecimal.valueOf(amount));
            } catch (Exception e) {
                return false;
            }
        }

        @Override
        public boolean withdraw(org.bukkit.OfflinePlayer player, double amount) {
            try {
                Object param = useUUID ? player.getUniqueId() : (withdrawMethod.getParameterTypes()[0] == String.class ? player.getName() : player);
                Object response = withdrawMethod.invoke(econ, param, java.math.BigDecimal.valueOf(amount));
                return (boolean) responseSuccessMethod.invoke(response);
            } catch (Exception e) {
                return false;
            }
        }

        @Override
        public boolean deposit(org.bukkit.OfflinePlayer player, double amount) {
            try {
                Object param = useUUID ? player.getUniqueId() : (depositMethod.getParameterTypes()[0] == String.class ? player.getName() : player);
                Object response = depositMethod.invoke(econ, param, java.math.BigDecimal.valueOf(amount));
                return (boolean) responseSuccessMethod.invoke(response);
            } catch (Exception e) {
                return false;
            }
        }

        @Override
        public String format(double amount) {
            try {
                return (String) formatMethod.invoke(econ, java.math.BigDecimal.valueOf(amount));
            } catch (Exception e) {
                return String.format("%.2f", amount);
            }
        }

        @Override
        public Object getProvider() {
            return econ;
        }
    }
    
    /**
     * Check if Vault economy is enabled and available
     */
    public boolean isEnabled() {
        return enabled && economy != null;
    }
    
    /**
     * Get player's balance
     */
    public double getBalance(Player player) {
        if (!isEnabled()) {
            return 0.0;
        }
        
        try {
            return economy.getBalance(player);
        } catch (Exception e) {
            MrLibConsoleSayer.MrSay_Error("Error getting balance for player " + player.getName() + ": " + e.getMessage());
            return 0.0;
        }
    }
    
    /**
     * Check if player has enough money
     */
    public boolean hasEnough(Player player, double amount) {
        if (!isEnabled()) {
            return false;
        }
        
        try {
            return economy.has(player, amount);
        } catch (Exception e) {
            MrLibConsoleSayer.MrSay_Error("Error checking balance for player " + player.getName() + ": " + e.getMessage());
            return false;
        }
    }
    
    /**
     * Deposit money to player's account
     */
    public boolean deposit(org.bukkit.OfflinePlayer player, double amount) {
        if (!isEnabled()) {
            return false;
        }
        
        try {
            return economy.deposit(player, amount);
        } catch (Exception e) {
            MrLibConsoleSayer.MrSay_Error("Error depositing money to player " + player.getName() + ": " + e.getMessage());
            if (e.getMessage() != null && e.getMessage().contains("zip file closed")) {
                MrLibConsoleSayer.MrSay_Error("Database connection issue detected. Try restarting the server.");
            }
            return false;
        }
    }
    
    /**
     * Withdraw money from player's account
     */
    public boolean withdraw(org.bukkit.OfflinePlayer player, double amount) {
        if (!isEnabled()) {
            return false;
        }
        
        try {
            return economy.withdraw(player, amount);
        } catch (Exception e) {
            MrLibConsoleSayer.MrSay_Error("Error withdrawing money from player " + player.getName() + ": " + e.getMessage());
            return false;
        }
    }
    
    /**
     * Format money amount using Vault's currency format
     */
    public String format(double amount) {
        if (!isEnabled()) {
            return String.format("%.2f", amount);
        }
        
        try {
            return economy.format(amount);
        } catch (Exception e) {
            return String.format("%.2f", amount);
        }
    }
    
    /**
     * Get currency symbol/name
     */
    public String getCurrencySymbol() {
        if (!isEnabled()) {
            return "$";
        }
        
        try {
            String formatted = economy.format(1.0);
            
            return formatted.replaceAll("[0-9.,\\s]", "").trim();
        } catch (Exception e) {
            return "$";
        }
    }
    
    /**
     * Get the raw Economy instance (for advanced usage)
     */
    public Object getEconomy() {
        return economy;
    }
}