package com.songoda.ultimatestacker.tasks;

import com.songoda.core.compatibility.CompatibleMaterial;
import com.songoda.core.compatibility.ServerVersion;
import com.songoda.core.hooks.WorldGuardHook;
import com.songoda.core.world.SWorld;
import com.songoda.ultimatestacker.UltimateStacker;
import com.songoda.ultimatestacker.settings.Settings;
import com.songoda.ultimatestacker.stackable.entity.Check;
import com.songoda.ultimatestacker.stackable.entity.EntityStack;
import com.songoda.ultimatestacker.stackable.entity.EntityStackManager;
import com.songoda.ultimatestacker.stackable.entity.StackedEntity;
import com.songoda.ultimatestacker.stackable.entity.custom.CustomEntity;
import com.songoda.ultimatestacker.utils.Async;
import com.songoda.ultimatestacker.utils.CachedChunk;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.World;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.entity.AbstractHorse;
import org.bukkit.entity.Ageable;
import org.bukkit.entity.ArmorStand;
import org.bukkit.entity.Cat;
import org.bukkit.entity.ChestedHorse;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Horse;
import org.bukkit.entity.HumanEntity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Llama;
import org.bukkit.entity.Ocelot;
import org.bukkit.entity.Parrot;
import org.bukkit.entity.Phantom;
import org.bukkit.entity.Pig;
import org.bukkit.entity.PufferFish;
import org.bukkit.entity.Rabbit;
import org.bukkit.entity.Sheep;
import org.bukkit.entity.Skeleton;
import org.bukkit.entity.Slime;
import org.bukkit.entity.Snowman;
import org.bukkit.entity.Tameable;
import org.bukkit.entity.TropicalFish;
import org.bukkit.entity.Villager;
import org.bukkit.entity.Wolf;
import org.bukkit.entity.Zombie;
import org.bukkit.inventory.EntityEquipment;
import org.bukkit.scheduler.BukkitRunnable;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.UUID;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;

public class StackingTask extends BukkitRunnable {

    private final UltimateStacker plugin;

    private final EntityStackManager stackManager;

    private final ConfigurationSection configurationSection = UltimateStacker.getInstance().getMobFile();
    private final List<UUID> processed = new ArrayList<>();

    private final Map<CachedChunk, Entity[]> cachedChunks = new HashMap<>();

    private final Map<EntityType, Integer> entityStackSizes = new HashMap<>();
    private final int maxEntityStackSize = Settings.MAX_STACK_ENTITIES.getInt(),
            minEntityStackSize = Settings.MIN_STACK_ENTITIES.getInt(),
            searchRadius = Settings.SEARCH_RADIUS.getInt(),
            maxPerTypeStacksPerChunk = Settings.MAX_PER_TYPE_STACKS_PER_CHUNK.getInt();
    private final List<String> disabledWorlds = Settings.DISABLED_WORLDS.getStringList(),
            stackReasons = Settings.STACK_REASONS.getStringList();
    private final List<Check> checks = Check.getChecks(Settings.STACK_CHECKS.getStringList());
    private final boolean stackFlyingDown = Settings.ONLY_STACK_FLYING_DOWN.getBoolean(),
            stackWholeChunk = Settings.STACK_WHOLE_CHUNK.getBoolean(),
            weaponsArentEquipment = Settings.WEAPONS_ARENT_EQUIPMENT.getBoolean(),
            onlyStackFromSpawners = Settings.ONLY_STACK_FROM_SPAWNERS.getBoolean(),
            onlyStackOnSurface = Settings.ONLY_STACK_ON_SURFACE.getBoolean();

    Set<SWorld> loadedWorlds = new HashSet<>();

    public StackingTask(UltimateStacker plugin) {
        this.plugin = plugin;
        this.stackManager = plugin.getEntityStackManager();

        // Add loaded worlds.
        for (World world : Bukkit.getWorlds())
            loadedWorlds.add(new SWorld(world));

        // Start the stacking task.
        runTaskTimerAsynchronously(plugin, 0, Settings.STACK_SEARCH_TICK_SPEED.getInt());
    }

    @Override
    public void run() {
        // Should entities be stacked?
        if (!Settings.STACK_ENTITIES.getBoolean()) return;

        // Loop through each world.
        for (SWorld sWorld : loadedWorlds) {
            // If world is disabled then continue to the next world.
            if (isWorldDisabled(sWorld.getWorld())) continue;

            // Get the loaded entities from the current world and reverse them.
            List<LivingEntity> entities;
            try {
                entities = getLivingEntitiesSync(sWorld).get();
            } catch (ExecutionException | InterruptedException ex) {
                ex.printStackTrace();
                continue;
            }
            Collections.reverse(entities);

            // Loop through the entities.
            for (LivingEntity entity : entities) {
                // Get entity location to pass around as its faster this way.
                Location location = entity.getLocation();

                // Check to see if entity is not stackable.
                if (!isEntityStackable(entity))
                    continue;

                // Make sure our entity has not already been processed.
                // Skip it if it has been.
                if (this.processed.contains(entity.getUniqueId())) continue;

                // Process the entity.
                this.processEntity(entity, sWorld, location);
            }
        }
        // Clear caches in preparation for the next run.
        this.processed.clear();
        this.cachedChunks.clear();
    }

    private Future<List<LivingEntity>> getLivingEntitiesSync(SWorld sWorld) {
        CompletableFuture<List<LivingEntity>> future = new CompletableFuture<>();
        Bukkit.getScheduler().scheduleSyncDelayedTask(this.plugin, () -> future.complete(sWorld.getLivingEntities()));

        return future;
    }

    private Future<Entity[]> getEntitiesInChunkSync(CachedChunk cachedChunk) {
        CompletableFuture<Entity[]> future = new CompletableFuture<>();
        Bukkit.getScheduler().scheduleSyncDelayedTask(this.plugin, () -> future.complete(cachedChunk.getEntities()));

        return future;
    }

    public boolean isWorldDisabled(World world) {
        return disabledWorlds.stream().anyMatch(worldStr -> world.getName().equalsIgnoreCase(worldStr));
    }

    private boolean isEntityStackable(Entity entity) {
        // Make sure we have the correct entity type and that it is valid.
        if (!entity.isValid()
                || entity instanceof HumanEntity
                || entity instanceof ArmorStand

                // Make sure the entity is not in love.
                || entity.hasMetadata("inLove")
                // Or in breeding cooldown.
                || entity.hasMetadata("breedCooldown"))
            return false;

        // Allow spawn if stackreasons are set and match, or if from a spawner
        final String spawnReason = entity.hasMetadata("US_REASON") && !entity.getMetadata("US_REASON").isEmpty()
                ? entity.getMetadata("US_REASON").get(0).asString() : null;
        List<String> stackReasons;
        if (onlyStackFromSpawners) {
            // If only stack from spawners is enabled, make sure the entity spawned from a spawner.
            if (!"SPAWNER".equals(spawnReason))
                return false;
        } else if (!(stackReasons = this.stackReasons).isEmpty() && !stackReasons.contains(spawnReason))
            // Only stack if on the list of events to stack
            return false;

        // Cast our entity to living entity.
        LivingEntity livingEntity = (LivingEntity) entity;

        // If only stack on surface is enabled make sure the entity is on a surface then entity is stackable.
        return !onlyStackOnSurface
                || canFly(livingEntity)
                || entity.getType().name().equals("SHULKER")

                || (livingEntity.isOnGround()
                || (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_13)
                && livingEntity.isSwimming()));

    }

    private void processEntity(LivingEntity livingEntity, SWorld sWorld, Location location) {
        // Get the stack from the entity. It should be noted that this value will
        // be null if our entity is not a stack.
        EntityStack stack = plugin.getEntityStackManager().getStack(livingEntity);

        // Is this entity stacked?
        boolean isStack = stack != null;

        // The amount that is stackable.
        int amountToStack = isStack ? stack.getAmount() : 1;

        // Attempt to split our stack. If the split is successful then skip this entity.
        if (isStack && attemptSplit(stack, livingEntity)) return;

        // If this entity is named, a custom entity or disabled then skip it.
        if (!isStack && (livingEntity.getCustomName() != null
                && plugin.getCustomEntityManager().getCustomEntity(livingEntity) == null)
                || !configurationSection.getBoolean("Mobs." + livingEntity.getType().name() + ".Enabled"))
            return;

        // Get the maximum stack size for this entity.
        int maxEntityStackSize = getEntityStackSize(livingEntity);

        // Get similar entities around our entity and make sure those entities are both compatible and stackable.
        List<LivingEntity> stackableFriends = new LinkedList<>();
        for (LivingEntity entity : getSimilarEntitiesAroundEntity(livingEntity, sWorld, location)) {
            // Check to see if entity is not stackable.
            if (!isEntityStackable(entity))
                continue;
            // Add this entity to our stackable friends.
            stackableFriends.add(entity);
        }

        // Loop through our similar stackable entities.
        for (LivingEntity entity : stackableFriends) {
            // Make sure the entity has not already been processed.
            if (this.processed.contains(entity.getUniqueId())) continue;

            // Check our WorldGuard flag.
            Boolean flag = WorldGuardHook.isEnabled() ? WorldGuardHook.getBooleanFlag(livingEntity.getLocation(), "mob-stacking") : null;
            if (flag != null && !flag)
                continue;

            // Get this entities friendStack.
            EntityStack friendStack = stackManager.getStack(entity);

            // Check to see if this entity is stacked and friendStack plus
            // our amount to stack is not above our max friendStack size
            // for this entity.
            if (friendStack != null && (friendStack.getAmount() + amountToStack) <= maxEntityStackSize) {

                // If we are a stack lets merge our stack with the just found friend stack.
                if (isStack) {
                    // Get the host entity.
                    StackedEntity host = stack.getHostAsStackedEntity();
                    // Get all the stacked entities in our stack and add them to a list.
                    List<StackedEntity> entities = stack.takeAllEntities();
                    // Add the host to this list.
                    entities.add(host);
                    // Add the collected entities to the new stack.
                    friendStack.addEntitiesToStackSilently(entities);
                    // Update friend stack to display changes.
                    friendStack.updateStack();
                    // Push changes to the database.
                    plugin.getDataManager().createStackedEntities(friendStack, entities);
                } else {
                    // If we are not stacked add ourselves to the found friendStack.
                    plugin.getDataManager().createStackedEntity(friendStack, friendStack.addEntityToStack(livingEntity));
                }

                // Drop lead if applicable then remove our entity and mark it as processed.
                if (livingEntity.isLeashed())
                    Bukkit.getScheduler().runTask(plugin, () -> livingEntity.getWorld()
                            .dropItemNaturally(livingEntity.getLocation(), CompatibleMaterial.LEAD.getItem()));
                Bukkit.getScheduler().runTask(plugin, livingEntity::remove);
                processed.add(livingEntity.getUniqueId());

                return;
            } else if (friendStack == null
                    && isStack
                    && (stack.getAmount() + 1) <= maxEntityStackSize
                    && canFly(entity)
                    && Settings.ONLY_STACK_FLYING_DOWN.getBoolean()
                    && location.getY() > entity.getLocation().getY()) {

                // Make the friend the new stack host.
                EntityStack newStack = stackManager.updateStack(livingEntity, entity);

                if (newStack == null) {
                    continue;
                }

                // Add our entity to that stack
                plugin.getDataManager().createStackedEntity(newStack, newStack.addEntityToStack(livingEntity));

                // Remove our entity and mark it as processed.
                Bukkit.getScheduler().runTask(plugin, livingEntity::remove);
                processed.add(livingEntity.getUniqueId());
                return;
            }
        }

        // If our entity is stacked then skip this entity.
        if (isStack) return;

        // Check our WorldGuard flag.
        Boolean flag = WorldGuardHook.isEnabled() ? WorldGuardHook.getBooleanFlag(livingEntity.getLocation(), "mob-stacking") : null;
        if (flag != null && !flag)
            return;

        // Remove all stacked entities from our stackable friends.
        stackableFriends.removeIf(stackManager::isStackedAndLoaded);

        // If the stack cap is met then delete this entity.
        if (maxPerTypeStacksPerChunk != -1
                && (getSimilarStacksInChunk(sWorld, livingEntity) + 1) > maxPerTypeStacksPerChunk) {
            Bukkit.getScheduler().runTask(plugin, livingEntity::remove);
            this.processed.add(livingEntity.getUniqueId());
            return;
        }

        // If there are none or not enough stackable friends left to create a new entity,
        // the stack sizes overlap then skip this entity.
        if (stackableFriends.isEmpty()
                || stackableFriends.size() < minEntityStackSize - 1
                || minEntityStackSize > maxEntityStackSize) return;

        // If a stack was never found create a new one.
        EntityStack newStack = stackManager.addStack(livingEntity);

        List<LivingEntity> livingEntities = new LinkedList<>();

        // Loop through the unstacked and unprocessed stackable friends while not creating
        // a stack larger than the maximum.
        stackableFriends.stream().filter(entity -> !stackManager.isStackedAndLoaded(entity)
                && !this.processed.contains(entity.getUniqueId())).limit(maxEntityStackSize).forEach(entity -> {

            // Make sure we're not naming some poor kids pet.
            if (entity.getCustomName() != null
                    && plugin.getCustomEntityManager().getCustomEntity(entity) == null) {
                processed.add(livingEntity.getUniqueId());
                newStack.destroy();
                return;
            }

            // Drop lead if applicable then remove our entity and mark it as processed.
            if (entity.isLeashed()) {
                Bukkit.getScheduler().runTask(plugin, () -> entity.getWorld().dropItemNaturally(entity.getLocation(), CompatibleMaterial.LEAD.getItem()));
            }
            livingEntities.add(entity);
            Bukkit.getScheduler().runTask(plugin, entity::remove);
            processed.add(entity.getUniqueId());

        });

        // Add our new approved entities to the new stack and commit them to the database.
        plugin.getDataManager().createStackedEntities(newStack,
                newStack.addRawEntitiesToStackSilently(livingEntities));

        // Update our stack.
        newStack.updateStack();
    }

    public boolean attemptSplit(EntityStack stack, LivingEntity livingEntity) {
        int stackSize = stack.getAmount();
        int maxEntityStackAmount = getEntityStackSize(livingEntity);

        if (stackSize <= maxEntityStackAmount) return false;

        // Destroy the stack.
        stack.destroy();

        Bukkit.getScheduler().runTask(plugin, () -> {
            for (int i = stackSize; i > 0; i -= maxEntityStackAmount) {
                LivingEntity entity = stack.takeOneAndSpawnEntity(livingEntity.getLocation());
                if (entity == null) continue;
                EntityStack newStack = plugin.getEntityStackManager().addStack(entity);
                newStack.moveEntitiesFromStack(stack, Math.min(i, maxEntityStackAmount) - 1);
                newStack.updateStack();
            }
        });

        // Remove our entity and mark it as processed.
        Bukkit.getScheduler().runTask(plugin, livingEntity::remove);
        processed.add(livingEntity.getUniqueId());
        return true;
    }

    private Set<CachedChunk> getNearbyChunks(SWorld sWorld, Location location, double radius, boolean singleChunk) {
        World world = location.getWorld();
        Set<CachedChunk> chunks = new HashSet<>();
        if (world == null) return chunks;

        CachedChunk firstChunk = new CachedChunk(sWorld, location);
        chunks.add(firstChunk);

        if (singleChunk) return chunks;

        int minX = (int) Math.floor(((location.getX() - radius) - 2.0D) / 16.0D);
        int maxX = (int) Math.floor(((location.getX() + radius) + 2.0D) / 16.0D);
        int minZ = (int) Math.floor(((location.getZ() - radius) - 2.0D) / 16.0D);
        int maxZ = (int) Math.floor(((location.getZ() + radius) + 2.0D) / 16.0D);

        for (int x = minX; x <= maxX; ++x) {
            for (int z = minZ; z <= maxZ; ++z) {
                if (firstChunk.getX() == x && firstChunk.getZ() == z) continue;
                chunks.add(new CachedChunk(sWorld, x, z));
            }
        }
        return chunks;
    }

    private List<LivingEntity> getNearbyEntities(SWorld sWorld, Location location, double radius, boolean singleChunk) {
        List<LivingEntity> entities = new ArrayList<>();
        for (CachedChunk chunk : getNearbyChunks(sWorld, location, radius, singleChunk)) {
            if (chunk == null) continue;
            Entity[] entityArray;
            if (cachedChunks.containsKey(chunk)) {
                entityArray = cachedChunks.get(chunk);
            } else {
                try {
                    entityArray = getEntitiesInChunkSync(chunk).get();
                    cachedChunks.put(chunk, entityArray);
                } catch (ExecutionException | InterruptedException ex) {
                    ex.printStackTrace();
                    continue;
                }
            }

            if (entityArray == null) continue;

            for (Entity e : entityArray) {
                if (e == null) continue;
                if (e.getWorld() != location.getWorld()
                        || !(e instanceof LivingEntity)
                        || (!singleChunk && location.distanceSquared(e.getLocation()) >= radius * radius)) continue;
                entities.add((LivingEntity) e);
            }
        }

        return entities;
    }

    public int getSimilarStacksInChunk(SWorld sWorld, LivingEntity entity) {
        int count = 0;
        for (LivingEntity e : getNearbyEntities(sWorld, entity.getLocation(), -1, true)) {
            if (entity.getType() == e.getType() && plugin.getEntityStackManager().isStackedAndLoaded(e))
                count++;
        }
        return count;
    }

    public List<LivingEntity> getSimilarEntitiesAroundEntity(LivingEntity initialEntity, SWorld sWorld, Location location) {
        // Create a list of all entities around the initial entity of the same type.
        List<LivingEntity> entityList = new LinkedList<>();

        for (LivingEntity entity : getNearbyEntities(sWorld, location, searchRadius, stackWholeChunk)) {
            if (entity.getType() != initialEntity.getType() || entity == initialEntity)
                continue;
            entityList.add(entity);
        }

        CustomEntity customEntity = plugin.getCustomEntityManager().getCustomEntity(initialEntity);
        if (customEntity != null)
            entityList.removeIf(entity -> !customEntity.isSimilar(initialEntity, entity));

        if (stackFlyingDown && canFly(initialEntity))
            entityList.removeIf(entity -> entity.getLocation().getY() > initialEntity.getLocation().getY());

        for (Check check : checks) {
            if (check == null) continue;
            switch (check) {
                case SPAWN_REASON: {
                    if (initialEntity.hasMetadata("US_REASON"))
                        entityList.removeIf(entity -> entity.hasMetadata("US_REASON") && !entity.getMetadata("US_REASON").get(0).asString().equals("US_REASON"));
                }
                case AGE: {
                    if (!(initialEntity instanceof Ageable)) break;

                    if (((Ageable) initialEntity).isAdult()) {
                        entityList.removeIf(entity -> !((Ageable) entity).isAdult());
                    } else {
                        entityList.removeIf(entity -> ((Ageable) entity).isAdult());
                    }
                    break;
                }
                case NERFED: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_9)) break;
                    entityList.removeIf(entity -> entity.hasAI() != initialEntity.hasAI());
                }
                case IS_TAMED: {
                    if (!(initialEntity instanceof Tameable)) break;
                    if (((Tameable) initialEntity).isTamed()) {
                        entityList.removeIf(entity -> !((Tameable) entity).isTamed());
                    } else {
                        entityList.removeIf(entity -> ((Tameable) entity).isTamed());
                    }
                }
                case ANIMAL_OWNER: {
                    if (!(initialEntity instanceof Tameable)) break;

                    Tameable tameable = ((Tameable) initialEntity);
                    entityList.removeIf(entity -> ((Tameable) entity).getOwner() != tameable.getOwner());
                }
                case PIG_SADDLE: {
                    if (!(initialEntity instanceof Pig)) break;
                    entityList.removeIf(entity -> ((Pig) entity).hasSaddle());
                    break;
                }
                case SKELETON_TYPE: {
                    if (!(initialEntity instanceof Skeleton)) break;

                    Skeleton skeleton = (Skeleton) initialEntity;
                    entityList.removeIf(entity -> ((Skeleton) entity).getSkeletonType() != skeleton.getSkeletonType());
                    break;
                }
                case SHEEP_COLOR: {
                    if (!(initialEntity instanceof Sheep)) break;

                    Sheep sheep = ((Sheep) initialEntity);
                    entityList.removeIf(entity -> ((Sheep) entity).getColor() != sheep.getColor());
                    break;
                }
                case SHEEP_SHEARED: {
                    if (!(initialEntity instanceof Sheep)) break;

                    Sheep sheep = ((Sheep) initialEntity);
                    if (sheep.isSheared()) {
                        entityList.removeIf(entity -> !((Sheep) entity).isSheared());
                    } else {
                        entityList.removeIf(entity -> ((Sheep) entity).isSheared());
                    }
                    break;
                }
                case SNOWMAN_DERPED: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_9)
                            || !(initialEntity instanceof Snowman)) break;

                    Snowman snowman = ((Snowman) initialEntity);
                    if (snowman.isDerp()) {
                        entityList.removeIf(entity -> !((Snowman) entity).isDerp());
                    } else {
                        entityList.removeIf(entity -> ((Snowman) entity).isDerp());
                    }
                    break;
                }
                case LLAMA_COLOR: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_11)
                            || !(initialEntity instanceof Llama)) break;
                    Llama llama = ((Llama) initialEntity);
                    entityList.removeIf(entity -> ((Llama) entity).getColor() != llama.getColor());
                    break;
                }
                case LLAMA_STRENGTH: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_11)
                            || !(initialEntity instanceof Llama)) break;
                    Llama llama = ((Llama) initialEntity);
                    entityList.removeIf(entity -> ((Llama) entity).getStrength() != llama.getStrength());
                    break;
                }
                case VILLAGER_PROFESSION: {
                    if (!(initialEntity instanceof Villager)) break;
                    Villager villager = ((Villager) initialEntity);
                    entityList.removeIf(entity -> ((Villager) entity).getProfession() != villager.getProfession());
                    break;
                }
                case SLIME_SIZE: {
                    if (!(initialEntity instanceof Slime)) break;
                    Slime slime = ((Slime) initialEntity);
                    entityList.removeIf(entity -> ((Slime) entity).getSize() != slime.getSize());
                    break;
                }
                case HORSE_CARRYING_CHEST: {
                    if (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_11)) {
                        if (!(initialEntity instanceof ChestedHorse)) break;
                        entityList.removeIf(entity -> ((ChestedHorse) entity).isCarryingChest());
                    } else {
                        if (!(initialEntity instanceof Horse)) break;
                        entityList.removeIf(entity -> ((Horse) entity).isCarryingChest());
                    }
                    break;
                }
                case HORSE_HAS_ARMOR: {
                    if (!(initialEntity instanceof Horse)) break;
                    entityList.removeIf(entity -> ((Horse) entity).getInventory().getArmor() != null);
                    break;
                }
                case HORSE_HAS_SADDLE: {
                    if (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_13)
                            && initialEntity instanceof AbstractHorse) {
                        entityList.removeIf(entity -> ((AbstractHorse) entity).getInventory().getSaddle() != null);
                        break;
                    }
                    if (!(initialEntity instanceof Horse)) break;
                    entityList.removeIf(entity -> ((Horse) entity).getInventory().getSaddle() != null);
                    break;
                }
                case HORSE_JUMP: {
                    if (ServerVersion.isServerVersionAtLeast(ServerVersion.V1_11)) {
                        if (!(initialEntity instanceof AbstractHorse)) break;
                        AbstractHorse horse = ((AbstractHorse) initialEntity);
                        entityList.removeIf(entity -> ((AbstractHorse) entity).getJumpStrength() != horse.getJumpStrength());
                    } else {
                        if (!(initialEntity instanceof Horse)) break;
                        Horse horse = ((Horse) initialEntity);
                        entityList.removeIf(entity -> ((Horse) entity).getJumpStrength() != horse.getJumpStrength());

                    }
                    break;
                }
                case HORSE_COLOR: {
                    if (!(initialEntity instanceof Horse)) break;
                    Horse horse = ((Horse) initialEntity);
                    entityList.removeIf(entity -> ((Horse) entity).getColor() != horse.getColor());
                    break;
                }
                case HORSE_STYLE: {
                    if (!(initialEntity instanceof Horse)) break;
                    Horse horse = ((Horse) initialEntity);
                    entityList.removeIf(entity -> ((Horse) entity).getStyle() != horse.getStyle());
                    break;
                }
                case ZOMBIE_BABY: {
                    if (!(initialEntity instanceof Zombie)) break;
                    Zombie zombie = (Zombie) initialEntity;
                    entityList.removeIf(entity -> ((Zombie) entity).isBaby() != zombie.isBaby());
                    break;
                }
                case WOLF_COLLAR_COLOR: {
                    if (!(initialEntity instanceof Wolf)) break;
                    Wolf wolf = (Wolf) initialEntity;
                    entityList.removeIf(entity -> ((Wolf) entity).getCollarColor() != wolf.getCollarColor());
                    break;
                }
                case OCELOT_TYPE: {
                    if (!(initialEntity instanceof Ocelot)) break;
                    Ocelot ocelot = (Ocelot) initialEntity;
                    entityList.removeIf(entity -> ((Ocelot) entity).getCatType() != ocelot.getCatType());
                }
                case CAT_TYPE: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_14)
                            || !(initialEntity instanceof Cat)) break;
                    Cat cat = (Cat) initialEntity;
                    entityList.removeIf(entity -> ((Cat) entity).getCatType() != cat.getCatType());
                    break;
                }
                case HAS_EQUIPMENT: {
                    if (initialEntity.getEquipment() == null) break;
                    boolean imEquipped = isEquipped(initialEntity);
                    if (imEquipped)
                        entityList = new ArrayList<>();
                    else
                        entityList.removeIf(this::isEquipped);
                    break;
                }
                case RABBIT_TYPE: {
                    if (!(initialEntity instanceof Rabbit)) break;
                    Rabbit rabbit = (Rabbit) initialEntity;
                    entityList.removeIf(entity -> ((Rabbit) entity).getRabbitType() != rabbit.getRabbitType());
                    break;
                }
                case PARROT_TYPE: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_12)
                            || !(initialEntity instanceof Parrot)) break;
                    Parrot parrot = (Parrot) initialEntity;
                    entityList.removeIf(entity -> ((Parrot) entity).getVariant() != parrot.getVariant());
                    break;
                }
                case PUFFERFISH_STATE: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_13)
                            || !(initialEntity instanceof PufferFish)) break;
                    PufferFish pufferFish = (PufferFish) initialEntity;
                    entityList.removeIf(entity -> ((PufferFish) entity).getPuffState() != pufferFish.getPuffState());
                    break;
                }
                case TROPICALFISH_PATTERN: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_13)
                            || !(initialEntity instanceof TropicalFish)) break;
                    TropicalFish tropicalFish = (TropicalFish) initialEntity;
                    entityList.removeIf(entity -> ((TropicalFish) entity).getPattern() != tropicalFish.getPattern());
                    break;
                }
                case TROPICALFISH_PATTERN_COLOR: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_13)
                            || !(initialEntity instanceof TropicalFish)) break;
                    TropicalFish tropicalFish = (TropicalFish) initialEntity;
                    entityList.removeIf(entity -> ((TropicalFish) entity).getPatternColor() != tropicalFish.getPatternColor());
                    break;
                }
                case TROPICALFISH_BODY_COLOR: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_13)
                            || !(initialEntity instanceof TropicalFish)) break;
                    TropicalFish tropicalFish = (TropicalFish) initialEntity;
                    entityList.removeIf(entity -> ((TropicalFish) entity).getBodyColor() != tropicalFish.getBodyColor());
                    break;
                }
                case PHANTOM_SIZE: {
                    if (!ServerVersion.isServerVersionAtLeast(ServerVersion.V1_13)
                            || !(initialEntity instanceof Phantom)) break;
                    Phantom phantom = (Phantom) initialEntity;
                    entityList.removeIf(entity -> ((Phantom) entity).getSize() != phantom.getSize());
                    break;
                }
            }
        }

        if (initialEntity.hasMetadata("breedCooldown")) {
            entityList.removeIf(entity -> !entity.hasMetadata("breedCooldown"));
        }

        return entityList;
    }

    public boolean isEquipped(LivingEntity initialEntity) {
        if (initialEntity.getEquipment() == null) return false;
        EntityEquipment equipment = initialEntity.getEquipment();

        return (equipment.getItemInHand().getType() != Material.AIR
                && !weaponsArentEquipment && !equipment.getItemInHand().getEnchantments().isEmpty()
                || (equipment.getHelmet() != null && equipment.getHelmet().getType() != Material.AIR)
                || (equipment.getChestplate() != null && equipment.getChestplate().getType() != Material.AIR)
                || (equipment.getLeggings() != null && equipment.getLeggings().getType() != Material.AIR)
                || (equipment.getBoots() != null && equipment.getBoots().getType() != Material.AIR));
    }

    private int getEntityStackSize(LivingEntity initialEntity) {
        Integer max = entityStackSizes.get(initialEntity.getType());
        if (max == null) {
            max = configurationSection.getInt("Mobs." + initialEntity.getType().name() + ".Max Stack Size");
            if (max == -1) {
                max = maxEntityStackSize;
            }
            entityStackSizes.put(initialEntity.getType(), max);
        }
        return max;
    }

    public boolean canFly(LivingEntity entity) {
        switch (entity.getType()) {
            case GHAST:
            case BLAZE:
            case PHANTOM:
            case BAT:
            case BEE:
                return true;
            default:
                return false;
        }
    }
}