/**
 * Economy (soft-dependency on Vault)
 * - If a Vault-based economy was not found, disable the bounty system
 */
private void setupEconomy() {
    if (Bukkit.getPluginManager().getPlugin("Vault") != null) {
        RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServicesManager().getRegistration(Economy.class);
        if (economyProvider != null) {
            economy = economyProvider.getProvider();
        }
    }

    if (economy == null) {
        instance.getLogger().warning("Bounty-system [disabled], Vault economy not found");
        for (Permission permission : Bukkit.getPluginManager().getDefaultPermissions(false)) {
            if (permission.getName().startsWith("globalwarming.bounty")) {
                Bukkit.getPluginManager().getPermission(permission.getName())
                        .setDefault(PermissionDefault.FALSE);
            }
        }
    } else {
        instance.getLogger().info("Bounty-system [enabled], Vault economy found");
    }
}
 

boolean setupEconomy(ClaimChunk instance) {
    this.instance = instance;

    // Check if Vault is present
    if (instance.getServer().getPluginManager().getPlugin("Vault") == null) return false;

    // Get the Vault service if it is present
    RegisteredServiceProvider<Economy> rsp = instance.getServer().getServicesManager().getRegistration(Economy.class);

    // Check if the service is valid
    if (rsp == null) return false;

    // Update current economy handler
    econ = rsp.getProvider();

    // Success
    return true;
}
 

public Permission getPermissions() {
    if (permission != null) {
        return permission;
    } else {
        try {
            Class.forName("net.milkbowl.vault.permission.Permission");
            RegisteredServiceProvider<Permission> provider = Bukkit.getServer().getServicesManager().getRegistration(net.milkbowl.vault.permission.Permission.class);
            if (provider == null) {
                DiscordSRV.debug("Can't access permissions: registration provider was null");
                return null;
            }
            return permission = provider.getProvider();
        } catch (ClassNotFoundException e) {
            if (!warnedAboutMissingVault) {
                DiscordSRV.error("Group synchronization failed: Vault classes couldn't be found (did it enable properly?). Vault is required for synchronization to work.");
                warnedAboutMissingVault = true;
            }
            return null;
        }
    }
}
 

@Override
public void hook() {
    RegisteredServiceProvider<Permission> permissionProvider = Bukkit.getServer().getServicesManager()
            .getRegistration(net.milkbowl.vault.permission.Permission.class);
    if (permissionProvider != null) {
        permission = permissionProvider.getProvider();
    }
    RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServer().getServicesManager()
            .getRegistration(net.milkbowl.vault.economy.Economy.class);
    if (economyProvider != null) {
        economy = economyProvider.getProvider();
    }
    if (economy != null) {
        plugin.registerEvents("money", MoneyEvent.class);
        plugin.registerConditions("money", MoneyCondition.class);
        plugin.registerVariable("money", MoneyVariable.class);
    } else {
        LogUtils.getLogger().log(Level.WARNING, "There is no economy plugin on the server!");
    }
    if (permission != null) {
        plugin.registerEvents("permission", PermissionEvent.class);
    } else {
        LogUtils.getLogger().log(Level.WARNING, "Could not get permission provider!");
    }
}
 

public static void initHooks() {
    RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
    RegisteredServiceProvider<Permission> permissionProvider = Bukkit.getServer().getServicesManager().getRegistration(Permission.class);

    if (economyProvider != null) {
        economyHook = economyProvider.getProvider();
    }
    else {
        FunnyGuilds.getInstance().getPluginLogger().warning("No economy provider found, some features may not be available");
    }

    if (permissionProvider != null) {
        permissionHook = permissionProvider.getProvider();
    }
    else {
        FunnyGuilds.getInstance().getPluginLogger().warning("No permission provider found, some features may not be available");
    }
}
 

/**
 * Returns the Vault Permission interface.
 *
 * @param server the bukkit server instance
 * @return the vault permission instance
 * @throws PermissionHandlerException if the vault permission instance cannot be retrieved
 */
@VisibleForTesting
Permission getVaultPermission(Server server) throws PermissionHandlerException {
    // Get the permissions provider service
    RegisteredServiceProvider<Permission> permissionProvider = server
        .getServicesManager().getRegistration(Permission.class);
    if (permissionProvider == null) {
        throw new PermissionHandlerException("Could not load permissions provider service");
    }

    // Get the Vault provider and make sure it's valid
    Permission vaultPerms = permissionProvider.getProvider();
    if (vaultPerms == null) {
        throw new PermissionHandlerException("Could not load Vault permissions provider");
    }
    return vaultPerms;
}
 

private boolean setupEconomy() {
    if (getServer().getPluginManager().getPlugin("Vault") == null) {
        return false;
    }
    RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
    if (rsp == null) {
        return false;
    }

    econ = rsp.getProvider();
    return true;
}
 

public static void Vault_loadProviders() {
	RegisteredServiceProvider<Economy> rspEconomy = Bukkit.getServicesManager().getRegistration(Economy.class);
	if (rspEconomy != null) Vault_economy = rspEconomy.getProvider();
	RegisteredServiceProvider<Permission> rspPermission = Bukkit.getServicesManager().getRegistration(Permission.class);
	if (rspPermission != null) Vault_permission = rspPermission.getProvider();
	RegisteredServiceProvider<Chat> rspChat = Bukkit.getServicesManager().getRegistration(Chat.class);
	if (rspChat != null) Vault_chat = rspChat.getProvider();
}
 

@Deprecated
public VaultPermissionProvider() {
    RegisteredServiceProvider<Permission> rsp =
            Bukkit.getServer().getServicesManager().getRegistration(Permission.class);
    if (rsp == null) {
        throw new ProviderIsEmptyException(getName());
    }
    api = rsp.getProvider();
}
 

public static @NotNull EconomyCore getEconomyCore(@NotNull EconomyCore def) {
    @Nullable RegisteredServiceProvider<? extends EconomyCore> registeredServiceProvider =
            Bukkit.getServicesManager().getRegistration(EconomyCore.class);
    if (registeredServiceProvider == null) {
        return def;
    } else {
        return registeredServiceProvider.getProvider();
    }
}
 

public static @NotNull ItemMatcher getItemMatcher(@NotNull ItemMatcher def) {
    @Nullable RegisteredServiceProvider<? extends ItemMatcher> registeredServiceProvider =
            Bukkit.getServicesManager().getRegistration(ItemMatcher.class);
    if (registeredServiceProvider == null) {
        return def;
    } else {
        return registeredServiceProvider.getProvider();
    }
}
 

public static @NotNull GameLanguage getGameLanguage(@NotNull GameLanguage def) {
    @Nullable RegisteredServiceProvider<? extends GameLanguage> registeredServiceProvider =
            Bukkit.getServicesManager().getRegistration(GameLanguage.class);
    if (registeredServiceProvider == null) {
        return def;
    } else {
        return registeredServiceProvider.getProvider();
    }
}
 

public static @NotNull DatabaseCore getDatabaseCore(@NotNull DatabaseCore def) {
    @Nullable RegisteredServiceProvider<? extends DatabaseCore> registeredServiceProvider =
            Bukkit.getServicesManager().getRegistration(DatabaseCore.class);
    if (registeredServiceProvider == null) {
        return def;
    } else {
        return registeredServiceProvider.getProvider();
    }
}
 

private boolean setupEconomy() {
    RegisteredServiceProvider<net.milkbowl.vault.economy.Economy> economyProvider;
    try {
        economyProvider = Bukkit.getServicesManager().getRegistration(net.milkbowl.vault.economy.Economy.class);
    } catch (Throwable e) {
        return false;
    }

    if (economyProvider != null) {
        this.vault = economyProvider.getProvider();
    }

    if (this.vault == null) {
        return false;
    }

    if (this.vault.getName() == null || this.vault.getName().isEmpty()) {
        plugin
                .getLogger()
                .warning(
                        "Current economy plugin not correct process all request, this usually cause by irregular code, you should report this issue to your economy plugin author or use other economy plugin.");
        plugin
                .getLogger()
                .warning(
                        "This is technical information, please send this to economy plugin author: "
                                + "VaultEconomyProvider.getName() return a null or empty.");
    } else {
        plugin.getLogger().info("Using economy system: " + this.vault.getName());
    }
    Bukkit.getPluginManager().registerEvents(this, plugin);
    Util.debugLog("Economy service listener was registered.");
    return true;
}
 

private boolean setupEconomy() {
    if (getServer().getPluginManager().getPlugin("Vault") == null) {
        return false;
    }
    RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
    if (rsp == null) {
        return false;
    }

    econ = rsp.getProvider();
    return true;
}
 

@Override
public List<String> getGroups(Player player) {
    RegisteredServiceProvider<Permission> serviceProvider = Bukkit.getServer().getServicesManager()
            .getRegistration(Permission.class);
    groupPrefix = LWC.getInstance().getConfiguration().getString("core.groupPrefix", "group.");
    if (serviceProvider == null) {
        return super.getGroups(player);
    }

    Permission perm = serviceProvider.getProvider();

    try {
        // the player's groups
        String[] groups = perm.getPlayerGroups(player);

        // fallback to superperms if it appears that they have no groups
        if (groups == null || groups.length == 0) {
            return super.getGroups(player);
        }

        List<String> groupss = Arrays.asList(groups);

        for (PermissionAttachmentInfo pai : player.getEffectivePermissions()) {
            if (pai.getPermission().startsWith(groupPrefix)) {
                groupss.add(pai.getPermission().substring(groupPrefix.length()));
            }
        }

        return groupss;
    } catch (UnsupportedOperationException e) {
        // Can be thrown by vault or asList. Thrown by Vault when using SuperPerms -
        // getPlayerGroups() will throw it :-(
        return super.getGroups(player);
    }
}
 

/**
 * Check for an economy providor and set it if it was found
 */
private void checkEconomy() {
    RegisteredServiceProvider<Economy> serviceProvider = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);

    if (serviceProvider != null) {
        economy = serviceProvider.getProvider();
    }
}
 

private boolean setupEconomy() {
    if (getServer().getPluginManager().getPlugin("Vault") == null) {
        return false;
    }
    RegisteredServiceProvider<Economy> rsp = getServer().getServicesManager().getRegistration(Economy.class);
    if (rsp == null) {
        return false;
    }
    econ = rsp.getProvider();
    return econ != null;
}
 

/**
 * Loads a service instance
 *
 * @param clazz the service class
 * @param <T> the service class type
 * @return the service instance, as an optional
 */
@Nonnull
public static <T> Optional<T> get(@Nonnull Class<T> clazz) {
    Objects.requireNonNull(clazz, "clazz");
    RegisteredServiceProvider<T> registration = Bukkit.getServicesManager().getRegistration(clazz);
    if (registration == null) {
        return Optional.empty();
    }
    return Optional.ofNullable(registration.getProvider());
}
 

public static boolean setupEconomy() {
	if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
		return false;
	}
	RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
	if (rsp == null) {
		return false;
	}
	econ = rsp.getProvider();
	return econ != null;
}
 

public static void setupEconomy(){
  	if(!GameManager.getGameManager().getConfiguration().getVaultLoaded()){
  		return;
}

  	RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
   if (economyProvider != null) {
       economy = economyProvider.getProvider();
   }else{
   	Bukkit.getLogger().severe("[UhcCore] Error trying to load economy provider. Check that you have a economy plugin installed");
   }
  }
 

private boolean setupEconomy() {
	boolean ret = false;
	RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
	if (rsp != null) {
		economy = rsp.getProvider();
		ret = economy != null;
	}
	return ret;
}
 

public static boolean setupEconomy() {
    if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
        return false;
    }
    RegisteredServiceProvider<Economy> rsp = Bukkit.getServer().getServicesManager().getRegistration(Economy.class);
    if (rsp == null) {
        return false;
    }
    econ = rsp.getProvider();
    return econ != null;
}
 

@Override
public void initialize() {
    RegisteredServiceProvider<Economy> rsp = plugin.getServer().getServicesManager().getRegistration(Economy.class);

    if (rsp == null || (economy = rsp.getProvider()) == null) {
        plugin.getLogger().warning("No economy provider for Vault found!");
        plugin.getLogger().warning("Economy support by Vault is now disabled.");
        return;
    }

    plugin.getServer().getPluginManager().registerEvents(this, plugin);
    runTaskTimer(plugin, liquidUpdateTicks, liquidUpdateTicks);
    enabled = true;
}
 

private boolean setupEconomy() {
    if (getServer().getPluginManager().getPlugin("Vault") == null) {
        return false;
    }
    RegisteredServiceProvider<Economy> rsp = getServer()
            .getServicesManager().getRegistration(Economy.class);
    if (rsp == null) {
        return false;
    }
    econ = rsp.getProvider();
    return econ != null;
}
 

private boolean setupEconomy()
{
    RegisteredServiceProvider<Economy> economyProvider = Bukkit.getServer().getServicesManager().getRegistration(net.milkbowl.vault.economy.Economy.class);
    if (economyProvider != null) {
        economy = economyProvider.getProvider();
    }

    return (economy != null);
}
 

/**
 * Fills the {@code vaultPerms} object if possible.
 */
public void tryGetPerms() {
    if (Bukkit.getServer().getPluginManager().getPlugin("Vault") == null) {
        return;
    }
    try {
        RegisteredServiceProvider<Permission> rsp = Bukkit.getServer().getServicesManager().getRegistration(Permission.class);
        vaultPerms = rsp.getProvider();
        getLogger().info("Vault linked! Group targets will work.");
    }
    catch (Exception e) {
        e.printStackTrace();
    }
}
 

private boolean verifyEcon()
{
	if(Bukkit.getPluginManager().getPlugin("Vault") == null) 
		return false;
	//Bukkit.getLogger().info("Here 1");
	RegisteredServiceProvider<Economy> rsp = Bukkit.getServicesManager().getRegistration(Economy.class);
	if (rsp == null) 
	    return false;
	//Bukkit.getLogger().info("Here 2");
	econ = rsp.getProvider();
	//Bukkit.getLogger().info("Here 3");
	return econ != null;
}
 

public static String[] getGroups() {
    if (!PluginUtil.pluginHookIsEnabled("vault")) return new String[] {};

    try {
        RegisteredServiceProvider<?> service = Bukkit.getServer().getServicesManager().getRegistration(Class.forName("net.milkbowl.vault.permission.Permission"));
        if (service == null) return new String[] {};

        Method getGroupsMethod = service.getProvider().getClass().getMethod("getGroups");
        return (String[]) getGroupsMethod.invoke(service.getProvider());
    } catch (Exception ignored) { }
    return new String[] {};
}
 

public boolean hasPermission(OfflinePlayer offlinePlayer, String permNode) {
    RegisteredServiceProvider<Permission> rsp = this.plugin.getServer().getServicesManager().getRegistration(Permission.class);

    if ((offlinePlayer == null) || (offlinePlayer.getUniqueId() == null) || Strings.isNullOrEmpty(offlinePlayer.getName())) {
        return false;
    }

    return (rsp != null) && rsp.getProvider().playerHas(null, offlinePlayer, permNode);
}