/**
 * Adds this permission to the specified parent permission.
 * <p>
 * If the parent permission does not exist, it will be created and
 * registered.
 *
 * @param name  Name of the parent permission
 * @param value The value to set this permission to
 * @return Parent permission it created or loaded
 */
public Permission addParent(String name, boolean value) {
    PluginManager pm = Bukkit.getServer().getPluginManager();
    String lname = name.toLowerCase(java.util.Locale.ENGLISH);

    Permission perm = pm.getPermission(lname);

    if (perm == null) {
        perm = new Permission(lname);
        pm.addPermission(perm);
    }

    addParent(perm, value);

    return perm;
}
 

private void loadHooks() {
    PluginManager manager = plugin.getServer().getPluginManager();

    Plugin plan;
    if ((plan = manager.getPlugin("Plan")) != null) {
        consoleCommandIssuer.sendInfo(Message.GENERAL__HOOK_ENABLE, "{plugin}", "Plan");
        PlayerAnalyticsHook.create(plugin, plan);
    } else {
        consoleCommandIssuer.sendInfo(Message.GENERAL__HOOK_DISABLE, "{plugin}", "Plan");
    }

    if (manager.getPlugin("PlaceholderAPI") != null) {
        consoleCommandIssuer.sendInfo(Message.GENERAL__HOOK_ENABLE, "{plugin}", "PlaceholderAPI");
        ServiceLocator.register(new PlaceholderAPIHook());
    } else {
        consoleCommandIssuer.sendInfo(Message.GENERAL__HOOK_DISABLE, "{plugin}", "PlaceholderAPI");
    }
}
 

@Inject NicknameCommands(NicknameConfiguration config,
                         SyncExecutor syncExecutor,
                         UserService userService,
                         Audiences audiences,
                         IdentityProvider identities,
                         OnlinePlayers onlinePlayers,
                         UserFinder userFinder,
                         PluginManager pluginManager,
                         Plugin plugin) {
    this.config = config;
    this.syncExecutor = syncExecutor;
    this.userService = userService;
    this.audiences = audiences;
    this.identities = identities;
    this.onlinePlayers = onlinePlayers;
    this.userFinder = userFinder;
    this.pluginManager = pluginManager;
    this.plugin = plugin;
}
 

@Test
public void shouldSetSocialSpyStatus() {
    // given
    Player player = mock(Player.class);

    Essentials ess = mock(Essentials.class);
    User user = mock(User.class);
    given(ess.getUser(player)).willReturn(user);

    PluginManager pluginManager = mock(PluginManager.class);
    setPluginAvailable(pluginManager, ESSENTIALS, ess);
    PluginHookService pluginHookService = new PluginHookService(pluginManager);

    // when
    pluginHookService.setEssentialsSocialSpyStatus(player, true);

    // then
    verify(ess).getUser(player);
    verify(user).setSocialSpyEnabled(true);
}
 

public void uninject() {
    try {
        Objects.requireNonNull(DEFAULT_PERMISSIONS_FIELD, "DEFAULT_PERMISSIONS_FIELD");

        PluginManager pluginManager = this.plugin.getBootstrap().getServer().getPluginManager();
        if (!(pluginManager instanceof SimplePluginManager)) {
            return;
        }

        Object map = DEFAULT_PERMISSIONS_FIELD.get(pluginManager);
        if (map instanceof LuckPermsDefaultsMap) {
            LuckPermsDefaultsMap lpMap = (LuckPermsDefaultsMap) map;
            DEFAULT_PERMISSIONS_FIELD.set(pluginManager, new HashMap<>(lpMap));
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

private LuckPermsPermissionMap tryInject() throws Exception {
    Objects.requireNonNull(PERMISSIONS_FIELD, "PERMISSIONS_FIELD");
    PluginManager pluginManager = this.plugin.getBootstrap().getServer().getPluginManager();

    if (!(pluginManager instanceof SimplePluginManager)) {
        this.plugin.getLogger().severe("PluginManager instance is not a 'SimplePluginManager', instead: " + pluginManager.getClass());
        this.plugin.getLogger().severe("Unable to inject LuckPerms Permission map.");
        return null;
    }

    Object map = PERMISSIONS_FIELD.get(pluginManager);
    if (map instanceof LuckPermsPermissionMap && ((LuckPermsPermissionMap) map).plugin == this.plugin) {
        return null;
    }

    //noinspection unchecked
    Map<String, Permission> castedMap = (Map<String, Permission>) map;

    // make a new map & inject it
    LuckPermsPermissionMap newMap = new LuckPermsPermissionMap(this.plugin, castedMap);
    PERMISSIONS_FIELD.set(pluginManager, newMap);
    return newMap;
}
 

public void uninject() {
    try {
        Objects.requireNonNull(PERM_SUBS_FIELD, "PERM_SUBS_FIELD");

        PluginManager pluginManager = this.plugin.getBootstrap().getServer().getPluginManager();
        if (!(pluginManager instanceof SimplePluginManager)) {
            return;
        }

        Object map = PERM_SUBS_FIELD.get(pluginManager);
        if (map instanceof LuckPermsSubscriptionMap) {
            LuckPermsSubscriptionMap lpMap = (LuckPermsSubscriptionMap) map;
            PERM_SUBS_FIELD.set(pluginManager, lpMap.detach());
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

@Override
public void onEnable() {
    ICombatLogX plugin = getPlugin();
    ExpansionManager expansionManager = plugin.getExpansionManager();

    PluginManager manager = Bukkit.getPluginManager();
    Logger logger = getLogger();


    SkyBlockHook hook = SkyBlockHook.getSkyBlockHook(this);
    if(hook == null) {
        logger.info("A SkyBlock plugin could not be detected. If you believe this is an error please contact SirBlobman.");
        logger.info("Automatically disabling...");
        expansionManager.disableExpansion(this);
        return;
    }

    Listener listener = new ListenerSkyBlock(hook);
    expansionManager.registerListener(this, listener);
}
 

@Override
public void onActualEnable() {
    ICombatLogX plugin = getPlugin();
    ExpansionManager expansionManager = plugin.getExpansionManager();

    PluginManager manager = Bukkit.getPluginManager();
    Logger logger = getLogger();

    this.noEntryHandler = new FactionsNoEntryHandler(this);
    saveDefaultConfig("factions-compatibility.yml");

    NoEntryListener listener = new NoEntryListener(this);
    expansionManager.registerListener(this, listener);

    Plugin pluginProtocolLib = manager.getPlugin("ProtocolLib");
    if(pluginProtocolLib != null) {
        NoEntryForceFieldListener forceFieldListener = new NoEntryForceFieldListener(this);
        expansionManager.registerListener(this, forceFieldListener);

        String version = pluginProtocolLib.getDescription().getVersion();
        logger.info("Successfully hooked into ProtocolLib v" + version);
    }
}
 

@Override
public void onEnable() {
    INSTANCE = this;
    getLogger().info("Enabling PlotMe...Waiting for generator data.");
    serverObjectBuilder = new BukkitServerBridge(this, getLogger());
    plotme.registerServerBridge(serverObjectBuilder);
    getAPI().enable();
    doMetric();

    //Register Bukkit Events
    PluginManager pm = getServer().getPluginManager();
    BukkitPlotListener listener = new BukkitPlotListener(this);
    pm.registerEvents(listener, this);
    pm.registerEvents(new BukkitPlotDenyListener(this), this);
    plotme.getEventBus().register(listener);
    //Register Command
    this.getCommand("plotme").setExecutor(new BukkitCommand(this));
}
 

@Test
public void shouldUnhookEssentialsAndMultiverse() {
    // given
    PluginManager pluginManager = mock(PluginManager.class);
    setPluginAvailable(pluginManager, ESSENTIALS, Essentials.class);
    setPluginAvailable(pluginManager, MULTIVERSE, MultiverseCore.class);
    PluginHookService pluginHookService = new PluginHookService(pluginManager);

    // when
    pluginHookService.unhookEssentials();
    pluginHookService.unhookMultiverse();

    // then
    assertThat(pluginHookService.isEssentialsAvailable(), equalTo(false));
    assertThat(pluginHookService.isMultiverseAvailable(), equalTo(false));
}
 

private String replacePlaceholders(String string) {
    ICombatLogX plugin = this.expansion.getPlugin();
    Player player = getPlayer();
    if(player == null) return string;

    PluginManager manager = Bukkit.getPluginManager();
    if(manager.isPluginEnabled("PlaceholderAPI")) string = HookPlaceholderAPI.replacePlaceholders(player, string);
    if(manager.isPluginEnabled("MVdWPlaceholderAPI")) string = HookMVdWPlaceholderAPI.replacePlaceholders(player, string);

    String timeLeft = PlaceholderReplacer.getTimeLeftSeconds(plugin, player);
    String inCombat = PlaceholderReplacer.getInCombat(plugin, player);
    String combatStatus = PlaceholderReplacer.getCombatStatus(plugin, player);

    String enemyName = PlaceholderReplacer.getEnemyName(plugin, player);
    String enemyHealth = PlaceholderReplacer.getEnemyHealth(plugin, player);
    String enemyHealthRounded = PlaceholderReplacer.getEnemyHealthRounded(plugin, player);
    String enemyHearts = PlaceholderReplacer.getEnemyHearts(plugin, player);

    return string.replace("{time_left}", timeLeft)
            .replace("{in_combat}", inCombat)
            .replace("{status}", combatStatus)
            .replace("{enemy_name}", enemyName)
            .replace("{enemy_health}", enemyHealth)
            .replace("{enemy_health_rounded}", enemyHealthRounded)
            .replace("{enemy_hearts}", enemyHearts);
}
 

@Test
public void shouldReturnNullForNonMvWorld() {
    // given
    World world = mock(World.class);
    MVWorldManager mvWorldManager = mock(MVWorldManager.class);
    given(mvWorldManager.isMVWorld(world)).willReturn(false);

    PluginManager pluginManager = mock(PluginManager.class);
    MultiverseCore multiverse = mock(MultiverseCore.class);
    setPluginAvailable(pluginManager, MULTIVERSE, multiverse);
    given(multiverse.getMVWorldManager()).willReturn(mvWorldManager);
    PluginHookService pluginHookService = new PluginHookService(pluginManager);

    // when
    Location spawn = pluginHookService.getMultiverseSpawn(world);

    // then
    assertThat(spawn, nullValue());
    verify(mvWorldManager).isMVWorld(world);
    verify(mvWorldManager, never()).getMVWorld(world);
}
 

private static Server mockServer() {
    Server server = mock(Server.class);

    PluginManager pluginManager = mock(PluginManager.class);
    when(server.getPluginManager()).thenReturn(pluginManager);

    BukkitScheduler scheduler = mock(BukkitScheduler.class);
    when(server.getScheduler()).thenReturn(scheduler);

    setServer(server);
    return server;
}
 

@Override
public void onExecute(String[] args, CommandSender sender) {
    PluginManager plugins = Bukkit.getServer().getPluginManager();

    int maps = DungeonsXL.MAPS.listFiles().length - 1;
    int dungeons = DungeonsXL.DUNGEONS.listFiles().length;
    int loaded = plugin.getInstanceCache().size();
    int players = dPlayers.getAllInstancePlayers().size();
    Internals internals = CompatibilityHandler.getInstance().getInternals();
    String vault = "";
    if (plugins.getPlugin("Vault") != null) {
        vault = plugins.getPlugin("Vault").getDescription().getVersion();
    }
    String itemsxl = "";
    if (plugins.getPlugin("ItemsXL") != null) {
        itemsxl = plugins.getPlugin("ItemsXL").getDescription().getVersion();
    }

    MessageUtil.sendCenteredMessage(sender, "&4" + D[0] + "&f" + X[0] + L[0]);
    MessageUtil.sendCenteredMessage(sender, "&4" + D[1] + "&f" + X[1] + L[1]);
    MessageUtil.sendCenteredMessage(sender, "&4" + D[2] + "&f" + X[2] + L[2]);
    MessageUtil.sendCenteredMessage(sender, "&4" + D[3] + "&f" + X[3] + L[3]);
    MessageUtil.sendCenteredMessage(sender, "&4" + D[4] + "&f" + X[4] + L[4]);
    MessageUtil.sendCenteredMessage(sender, "&b&l###### " + DMessage.CMD_MAIN_WELCOME.getMessage() + "&7 v" + plugin.getDescription().getVersion() + " &b&l######");
    MessageUtil.sendCenteredMessage(sender, DMessage.CMD_MAIN_LOADED.getMessage(String.valueOf(maps), String.valueOf(dungeons), String.valueOf(loaded), String.valueOf(players)));
    MessageUtil.sendCenteredMessage(sender, DMessage.CMD_MAIN_COMPATIBILITY.getMessage(String.valueOf(internals), vault, itemsxl));
    MessageUtil.sendCenteredMessage(sender, DMessage.CMD_MAIN_HELP_INFO.getMessage());
    MessageUtil.sendCenteredMessage(sender, "&7\u00a92012-2020 Frank Baumann & contributors; lcsd. under GPLv3.");
}
 

@Test
public void shouldInitializeAllServices() {
    // given
    Injector injector = new InjectorBuilder().addDefaultHandlers("me.gnat008.perworldinventory").create();
    injector.register(PerWorldInventory.class, plugin);
    injector.register(Server.class, server);
    injector.register(PluginManager.class, pluginManager);
    injector.provide(DataFolder.class, dataFolder);
    injector.register(Settings.class, settings);
    injector.registerProvider(DataSource.class, DataSourceProvider.class);

    // when
    plugin.injectServices(injector);
    plugin.registerEventListeners(injector);
    plugin.registerCommands(injector);

    // then - check various samples
    assertThat(injector.getIfAvailable(GroupManager.class), not(nullValue()));
    assertThat(injector.getIfAvailable(DataSource.class), instanceOf(FlatFile.class));
    assertThat(injector.getIfAvailable(PWIPlayerManager.class), not(nullValue()));

    verifyRegisteredListener(PluginListener.class);
    verifyRegisteredListener(PlayerGameModeChangeListener.class);

    CommandVerifier commandVerifier = new CommandVerifier(plugin, injector);
    commandVerifier.assertHasCommand("pwi", PerWorldInventoryCommand.class);
    commandVerifier.assertHasCommand("reload", ReloadCommand.class);
    commandVerifier.assertHasCommand("setworlddefault", SetWorldDefaultCommand.class);
}
 

private <T extends Plugin> T getPlugin(PluginManager pluginManager, String name, Class<T> clazz)
    throws Exception, NoClassDefFoundError {
    if (pluginManager.isPluginEnabled(name)) {
        T plugin = clazz.cast(pluginManager.getPlugin(name));
        logger.info("Hooked successfully into " + name);
        return plugin;
    }
    return null;
}
 

/**
 * Register all of the events used by LWC
 */
private void registerEvents() {
    PluginManager pluginManager = Bukkit.getServer().getPluginManager();
    pluginManager.registerEvents(new LWCPlayerListener(this), this);
    pluginManager.registerEvents(new LWCEntityListener(this), this);
    pluginManager.registerEvents(new LWCBlockListener(this), this);
    pluginManager.registerEvents(new LWCServerListener(this), this);
    if (VersionUtil.getMinorVersion() > 13) {
        pluginManager.registerEvents(new LWC114Listener(), this);
    }
}
 

public FloorRegenerator retrieveRegeneratorInstance() {
    //If FastAsyncWorldEdit is installed, use a special fawe designed
    //generator for compatibility
    PluginManager pluginManager = Bukkit.getPluginManager();
    Plugin fawePlugin = pluginManager.getPlugin(FAWE_PLUGIN_NAME);
    if (fawePlugin != null && fawePlugin.isEnabled()) {
        return faweRegenerator;
    }

    return defaultRegenerator;
}
 

private void registerListeners() {
    PluginManager pm = getServer().getPluginManager();
    pm.registerEvents(injector.getInstance(GameListener.class), this);
    pm.registerEvents(injector.getInstance(SignListener.class), this);
    pm.registerEvents(injector.getInstance(UserListener.class), this);
    pm.registerEvents(injector.getInstance(ChatListener.class), this);
    pm.registerEvents(injector.getInstance(SignPlaceholders.class), this);
    pm.registerEvents(injector.getInstance(SignButtons.class), this);
    pm.registerEvents(injector.getInstance(CommandHandler.class), this);
    pm.registerEvents(injector.getInstance(StatListener.class), this);
}
 

/**
 * Setup PlotMe plugin hooks
 */
@Override
public void setupHooks() {
    PluginManager pluginManager = plotMeCorePlugin.getServer().getPluginManager();
    if (pluginManager.getPlugin("WorldEdit") != null) {
        WorldEdit.getInstance().getEventBus().register(new PlotWorldEditListener(plotMeCorePlugin.getAPI()));
    }

    setUsingLwc(pluginManager.getPlugin("LWC") != null);
}
 

@Override
protected void registerListeners() {
	getLoggerManager().logDebug(Constants.DEBUG_PLUGIN_REGISTERING, true);
	PluginManager pm = ((Plugin) getBootstrap()).getServer().getPluginManager();
	pm.registerEvents(new BukkitChatListener(this), ((Plugin) getBootstrap()));
	pm.registerEvents(new BukkitExpListener(this), ((Plugin) getBootstrap()));
	pm.registerEvents(new BukkitFightListener(this), ((Plugin) getBootstrap()));
	pm.registerEvents(new BukkitFollowListener(this), ((Plugin) getBootstrap()));
	pm.registerEvents(new BukkitJoinLeaveListener(this), ((Plugin) getBootstrap()));
}
 

@Test
public void shouldHookIntoCmiAtInitialization() {
    // given
    PluginManager pluginManager = mock(PluginManager.class);
    setPluginAvailable(pluginManager, CMI, Plugin.class);

    // when
    PluginHookService pluginHookService = new PluginHookService(pluginManager);

    // then
    assertThat(pluginHookService.isCmiAvailable(), equalTo(true));
}
 

public ChunkListener() {
    if (Settings.IMP.TICK_LIMITER.ENABLED) {
        PluginManager plm = Bukkit.getPluginManager();
        Plugin plugin = Fawe.<FaweBukkit>imp().getPlugin();
        plm.registerEvents(this, plugin);
        try {
            Fawe.debug("Detected " + BlockExplodeEvent.class);
            plm.registerEvents(new ChunkListener_8Plus(this), plugin);
        } catch (Throwable ignore) {}
        TaskManager.IMP.repeat(new Runnable() {
            @Override
            public void run() {
                rateLimit--;
                physicsFreeze = false;
                itemFreeze = false;
                lastZ = Integer.MIN_VALUE;
                physSkip = 0;
                physCancelPair = Long.MIN_VALUE;
                physCancel = false;

                counter.clear();
                for (Long2ObjectMap.Entry<Boolean> entry : badChunks.long2ObjectEntrySet()) {
                    long key = entry.getLongKey();
                    int x = MathMan.unpairIntX(key);
                    int z = MathMan.unpairIntY(key);
                    counter.put(key, badLimit);
                }
                badChunks.clear();
            }
        }, Settings.IMP.TICK_LIMITER.INTERVAL);
    }
}
 

private LuckPermsSubscriptionMap tryInject() throws Exception {
    Objects.requireNonNull(PERM_SUBS_FIELD, "PERM_SUBS_FIELD");
    PluginManager pluginManager = this.plugin.getBootstrap().getServer().getPluginManager();

    if (!(pluginManager instanceof SimplePluginManager)) {
        this.plugin.getLogger().severe("PluginManager instance is not a 'SimplePluginManager', instead: " + pluginManager.getClass());
        this.plugin.getLogger().severe("Unable to inject LuckPerms Permission Subscription map.");
        return null;
    }

    Object map = PERM_SUBS_FIELD.get(pluginManager);
    if (map instanceof LuckPermsSubscriptionMap) {
        if (((LuckPermsSubscriptionMap) map).plugin == this.plugin) {
            return null;
        }

        map = ((LuckPermsSubscriptionMap) map).detach();
    }

    //noinspection unchecked
    Map<String, Map<Permissible, Boolean>> castedMap = (Map<String, Map<Permissible, Boolean>>) map;

    // make a new subscription map & inject it
    LuckPermsSubscriptionMap newMap = new LuckPermsSubscriptionMap(this.plugin, castedMap);
    PERM_SUBS_FIELD.set(pluginManager, newMap);
    return newMap;
}
 

private void registerEvents() {
    PluginManager pluginManager = getServer().getPluginManager();
    pluginManager.registerEvents(new GeneralEventHandler(this), this);
    pluginManager.registerEvents(new PlayerBlockModifyEventHandler(this), this);
    pluginManager.registerEvents(new WorldChangeEvent(this), this);
    pluginManager.registerEvents(loginEvent = new LoginEvent(this), this);
    JoinEvent joinEvent = new JoinEvent(this);
    pluginManager.registerEvent(PlayerJoinEvent.class, joinEvent,
            getEventPriority(PlayerJoinEvent.class), joinEvent, this, false);
    QuitEvent quitEvent = new QuitEvent(this);
    pluginManager.registerEvent(PlayerQuitEvent.class, quitEvent,
            getEventPriority(PlayerQuitEvent.class), quitEvent, this, false);
}
 

@Override
public void onStart() {
	/* Register a listener to watch for killed mobs. */
	final PluginManager pluginManager = CivCraft.getPlugin().getServer().getPluginManager();
	pluginManager.registerEvents(this, CivCraft.getPlugin());
	
}
 

@Override
public boolean punish(Player player, PlayerUntagEvent.UntagReason punishReason, LivingEntity previousEnemy) {
    PlayerPunishEvent punishEvent = new PlayerPunishEvent(player, punishReason, previousEnemy);
    PluginManager manager = Bukkit.getPluginManager();

    manager.callEvent(punishEvent);
    if(punishEvent.isCancelled()) return false;

    checkKill(player);
    runPunishCommands(player, previousEnemy);
    return true;
}
 

@Override
public void onEnable() {
	log.info("enabled...");
	PluginManager pm = getServer().getPluginManager();
	
	dynmap = pm.getPlugin("dynmap");
	api = (DynmapAPI)dynmap;
	
	civcraft = pm.getPlugin("civcraft");

	markerapi = api.getMarkerAPI();
	
	townBorderSet = markerapi.createMarkerSet("townborder.markerset", "Town Borders", null, false);
	townBorderSet.setLayerPriority(10);
	townBorderSet.setHideByDefault(false);
	
	cultureSet = markerapi.createMarkerSet("townculture.markerset", "Culture", null, false);
	cultureSet.setLayerPriority(15);
	cultureSet.setHideByDefault(false);
	
	structureSet = markerapi.createMarkerSet("structures.markerset", "Structures", null, false);
	structureSet.setLayerPriority(20);
	structureSet.setHideByDefault(false);
	
	getServer().getScheduler().scheduleSyncRepeatingTask(this, 
			new CivCraftUpdateTask(this.api, this.markerapi, this.townBorderSet, this.cultureSet, this.structureSet), 40, 40);
}
 

private boolean failsPreTagEvent(Player player, LivingEntity enemy, PlayerPreTagEvent.TagType tagType, PlayerPreTagEvent.TagReason tagReason) {
    PluginManager manager = Bukkit.getPluginManager();
    PlayerPreTagEvent event = new PlayerPreTagEvent(player, enemy, tagType, tagReason);

    manager.callEvent(event);
    return event.isCancelled();
}