UltimateStacker/src/main/java/com/songoda/ultimatestacker/tasks/StackingTask.java

package com.songoda.ultimatestacker.tasks;

import com.songoda.ultimatestacker.UltimateStacker;
import com.songoda.ultimatestacker.entity.EntityStack;
import com.songoda.ultimatestacker.entity.EntityStackManager;
import com.songoda.ultimatestacker.utils.Methods;
import com.songoda.ultimatestacker.utils.settings.Setting;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitRunnable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.UUID;

public class StackingTask extends BukkitRunnable {

    private final UltimateStacker instance;

    public StackingTask(UltimateStacker instance) {
        this.instance = instance;

        // Start stacking task.
        runTaskTimer(instance, 0, Setting.STACK_SEARCH_TICK_SPEED.getInt());
    }

    @Override
    public void run() {
        int maxEntityStackSizeGlobal = Setting.MAX_STACK_ENTITIES.getInt();
        int minEntityStackAmount = Setting.MIN_STACK_ENTITIES.getInt();

        List<String> disabledWorlds = Setting.DISABLED_WORLDS.getStringList();

        EntityStackManager stackManager = instance.getEntityStackManager();
        for (World world : Bukkit.getWorlds()) {
            if (disabledWorlds.stream().anyMatch(worldStr -> world.getName().equalsIgnoreCase(worldStr))) continue;

            List<Entity> entities = world.getEntities();
            Collections.reverse(entities);

            List<UUID> removed = new ArrayList<>();

            nextEntity:
            for (Entity entityO : entities) {
                if (entityO == null
                        || entityO instanceof Player
                        || !entityO.isValid()
                        || !(entityO instanceof LivingEntity)
                        || !Setting.STACK_ENTITIES.getBoolean())
                    continue;

                LivingEntity initialEntity = (LivingEntity) entityO;

                if (initialEntity.isDead()
                        || !initialEntity.isValid()
                        || initialEntity instanceof ArmorStand
                        || initialEntity.hasMetadata("inLove")

                        || Setting.ONLY_STACK_FROM_SPAWNERS.getBoolean()
                        && !(initialEntity.hasMetadata("US_REASON")
                        && initialEntity.getMetadata("US_REASON").get(0).asString().equals("SPAWNER"))

                        || Setting.ONLY_STACK_ON_SURFACE.getBoolean()
                        && !Methods.canFly(initialEntity)
                        && (!initialEntity.isOnGround() && !initialEntity.getLocation().getBlock().isLiquid()))
                    continue;

                EntityStack initialStack = stackManager.getStack(initialEntity);
                if (initialStack == null && initialEntity.getCustomName() != null) continue;
                int amtToStack = initialStack != null ? initialStack.getAmount() : 1;

                ConfigurationSection configurationSection = UltimateStacker.getInstance().getMobFile().getConfig();

                if (!configurationSection.getBoolean("Mobs." + initialEntity.getType().name() + ".Enabled"))
                    continue;

                int maxEntityStackSize = maxEntityStackSizeGlobal;
                if (configurationSection.getInt("Mobs." + initialEntity.getType().name() + ".Max Stack Size") != -1)
                    maxEntityStackSize = configurationSection.getInt("Mobs." + initialEntity.getType().name() + ".Max Stack Size");

                List<LivingEntity> entityList = Methods.getSimilarEntitiesAroundEntity(initialEntity);
                entityList.removeIf(entity -> entity.hasMetadata("inLove")
                        || entity.hasMetadata("breedCooldown")

                        || Setting.ONLY_STACK_FROM_SPAWNERS.getBoolean()
                        && !(initialEntity.hasMetadata("US_REASON")
                        && initialEntity.getMetadata("US_REASON").get(0).asString().equals("SPAWNER")));

                for (LivingEntity entity : new ArrayList<>(entityList)) {
                    if (removed.contains(entity.getUniqueId())) continue;
                    EntityStack stack = stackManager.getStack(entity);
                    if (stack == null && entity.getCustomName() != null) {
                        entityList.remove(entity);
                        continue;
                    }

                    //If a stack was found add 1 to this stack.
                    if (stack != null && (stack.getAmount() + amtToStack) <= maxEntityStackSize) {
                        stack.addAmount(amtToStack);
                        stack.updateStack();
                        removed.add(initialEntity.getUniqueId());
                        initialEntity.remove();

                        continue nextEntity;
                    } else if (stack == null
                            && initialStack != null
                            && (initialStack.getAmount() + 1) <= maxEntityStackSize
                            && Methods.canFly(entity)
                            && Setting.ONLY_STACK_FLYING_DOWN.getBoolean()
                            && initialEntity.getLocation().getY() > entity.getLocation().getY()) {
                        stackManager.addStack(entity, initialStack.getAmount() + 1);
                        removed.add(initialEntity.getUniqueId());
                        initialEntity.remove();

                        continue nextEntity;
                    }
                }

                if (initialStack != null) continue;

                entityList.removeIf(stackManager::isStacked);

                if (entityList.size() < minEntityStackAmount - 1
                        || minEntityStackAmount > maxEntityStackSize
                        || minEntityStackAmount == 1 && entityList.size() == 0) continue;

                //If stack was never found make a new one.
                EntityStack stack = stackManager.addStack(new EntityStack(initialEntity, (entityList.size() + 1) >
                        maxEntityStackSize ? maxEntityStackSize : entityList.size() + 1));

                entityList.stream().filter(entity -> !stackManager.isStacked(entity)
                        && !removed.contains(entity.getUniqueId())).limit(maxEntityStackSize).forEach(entity -> {
                    removed.add(entity.getUniqueId());
                    entity.remove();
                });

                stack.updateStack();
            }
            entities.clear();
            removed.clear();
        }
    }

}