class="kw">package com.hypixel.hytale.server.spawning.suppression.system;

class="kw">import com.hypixel.fastutil.longs.Long2ObjectConcurrentHashMap;
class="kw">import com.hypixel.hytale.assetstore.event.LoadedAssetsEvent;
class="kw">import com.hypixel.hytale.assetstore.event.RemovedAssetsEvent;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedAssetMap;
class="kw">import com.hypixel.hytale.builtin.tagset.TagSetPlugin;
class="kw">import com.hypixel.hytale.builtin.tagset.config.NPCGroup;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.Archetype;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.SystemGroup;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.component.system.StoreSystem;
class="kw">import com.hypixel.hytale.event.EventRegistry;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.server.core.entity.UUIDComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.EntityModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.FromPrefab;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.FromWorldGen;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabCopyableComponent;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.spawning.SpawningPlugin;
class="kw">import com.hypixel.hytale.server.spawning.assets.spawnsuppression.SpawnSuppression;
class="kw">import com.hypixel.hytale.server.spawning.spawnmarkers.SpawnMarkerEntity;
class="kw">import com.hypixel.hytale.server.spawning.suppression.SpawnSuppressorEntry;
class="kw">import com.hypixel.hytale.server.spawning.suppression.component.ChunkSuppressionEntry;
class="kw">import com.hypixel.hytale.server.spawning.suppression.component.ChunkSuppressionQueue;
class="kw">import com.hypixel.hytale.server.spawning.suppression.component.SpawnSuppressionComponent;
class="kw">import com.hypixel.hytale.server.spawning.suppression.component.SpawnSuppressionController;
class="kw">import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import it.unimi.dsi.fastutil.longs.LongIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.Comparator;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.CopyOnWriteArrayList;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class SpawnSuppressionSystems {
   class="kw">public SpawnSuppressionSystems() {
   }

   class="kw">private class="kw">static void suppressSpawns(
      @Nonnull ResourceType<ChunkStore, ChunkSuppressionQueue> var0,
      @Nonnull ComponentType<EntityStore, SpawnMarkerEntity> var1,
      UUID var2,
      @Nonnull SpawnSuppressorEntry var3,
      @Nonnull SpawnSuppressionController var4,
      @Nonnull Store<EntityStore> var5,
      @Nonnull ChunkStore var6
   ) {
      String var7 = var3.getSuppressionId();
      SpawningPlugin.get().getLogger().at(Level.FINEST).log("Suppressing spawns with id '%s' from suppressor %s", var7, var2);
      SpawnSuppression var8 = SpawnSuppression.getAssetMap().getAsset(var7);
      if (var8 == null) {
         SpawningPlugin.get().getLogger().at(Level.WARNING).log("Spawn suppression config '%s' does not exist", var7);
      } else {
         int[] var9 = var8.getSuppressedGroupIds();
         Object var10;
         if (var9 != null && var9.length > 0) {
            var10 = new IntOpenHashSet();

            for (int var14 : var9) {
               IntSet var15 = TagSetPlugin.get(NPCGroup.class).getSet(var14);
               if (var15 != null) {
                  var10.addAll(var15);
               }
            }
         } else {
            var10 = null;
         }

         double var30 = var8.getRadius();
         Vector3d var31 = var3.getPosition();
         int var32 = MathUtil.floor(var31.x - var30) >> 5;
         int var33 = MathUtil.floor(var31.z - var30) >> 5;
         int var16 = MathUtil.floor(var31.x + var30) >> 5;
         int var17 = MathUtil.floor(var31.z + var30) >> 5;
         int var18 = MathUtil.floor(var31.y - var30);
         int var19 = MathUtil.floor(var31.y + var30);
         Long2ObjectConcurrentHashMap var20 = var4.getChunkSuppressionMap();

         for (int var21 = var32; var21 <= var16; var21++) {
            for (int var22 = var33; var22 <= var17; var22++) {
               long var23 = ChunkUtil.indexChunk(var21, var22);
               SpawningPlugin.get().getLogger().at(Level.FINEST).log("Suppressing chunk index %s with id '%s'", var23, var7);
               ChunkSuppressionEntry var25 = var20.get(var23);
               Object var26;
               if (var25 != null) {
                  var26 = new ObjectArrayList(var25.getSuppressionSpans());
               } else {
                  var26 = new ObjectArrayList();
               }

               var26.add(new ChunkSuppressionEntry.SuppressionSpan(var2, var18, var19, var10));
               var26.sort(Comparator.comparingInt(ChunkSuppressionEntry.SuppressionSpan::getMinY));
               ChunkSuppressionEntry var27 = new ChunkSuppressionEntry(var26);
               var20.put(var23, var27);
               Ref var28 = var6.getChunkReference(var23);
               if (var28 != null) {
                  ChunkSuppressionQueue var29 = var6.getStore().getResource(var0);
                  var29.queueForAdd(var28, var27);
                  SpawningPlugin.get().getLogger().at(Level.FINEST).log("Queueing annotation of chunk index %s with id '%s'", var23, var7);
               }
            }
         }

         if (var8.isSuppressSpawnMarkers()) {
            List var34 = SpatialResource.getThreadLocalReferenceList();
            SpatialResource var35 = var5.getResource(SpawningPlugin.get().getSpawnMarkerSpatialResource());
            var35.getSpatialStructure().collect(var31, var30, var34);

            for (int var36 = 0; var36 < var34.size(); var36++) {
               Ref var24 = var34.get(var36);
               SpawnMarkerEntity var37 = var5.getComponent(var24, var1);
               if (var37.isSuppressedBy(var8)) {
                  var37.suppress(var2);
                  HytaleLogger.Api var38 = SpawningPlugin.get().getLogger().at(Level.FINEST);
                  if (var38.isEnabled()) {
                     var38.log("Suppressing spawn marker %s", var5.getComponent(var24, UUIDComponent.getComponentType()).getUuid());
                  }
               }
            }
         }
      }
   }

   class="kw">public class="kw">static class EnsureNetworkSendable class="kw">extends HolderSystem<EntityStore> {
      class="kw">private class="kw">final Query<EntityStore> query = Query.and(SpawnSuppressionComponent.getComponentType(), Query.not(NetworkId.getComponentType()));

      class="kw">public EnsureNetworkSendable() {
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3) {
         var1.addComponent(NetworkId.getComponentType(), new NetworkId(var3.getExternalData().takeNextNetworkId()));
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3) {
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }
   }

   class="kw">public class="kw">static class Load class="kw">extends StoreSystem<EntityStore> {
      class="kw">private class="kw">final ResourceType<EntityStore, SpawnSuppressionController> spawnSuppressionControllerResourceType;
      class="kw">private class="kw">final ComponentType<EntityStore, SpawnMarkerEntity> spawnMarkerEntityComponentType;
      class="kw">private class="kw">final ResourceType<ChunkStore, ChunkSuppressionQueue> chunkSuppressionQueueResourceType;
      class="kw">private class="kw">final ComponentType<ChunkStore, ChunkSuppressionEntry> chunkSuppressionEntryComponentType;
      @Nonnull
      class="kw">private class="kw">final EventRegistry eventRegistry;

      class="kw">public Load(
         ResourceType<EntityStore, SpawnSuppressionController> var1,
         ComponentType<EntityStore, SpawnMarkerEntity> var2,
         ResourceType<ChunkStore, ChunkSuppressionQueue> var3,
         ComponentType<ChunkStore, ChunkSuppressionEntry> var4
      ) {
         this.spawnSuppressionControllerResourceType = var1;
         this.spawnMarkerEntityComponentType = var2;
         this.chunkSuppressionQueueResourceType = var3;
         this.chunkSuppressionEntryComponentType = var4;
         this.eventRegistry = new EventRegistry(new CopyOnWriteArrayList<>(), () -> true, null, SpawningPlugin.get().getEventRegistry());
         this.eventRegistry.register(LoadedAssetsEvent.class, SpawnSuppression.class, this::onSpawnSuppressionsLoaded);
         this.eventRegistry.register(RemovedAssetsEvent.class, SpawnSuppression.class, this::onSpawnSuppressionsRemoved);
      }

      @Override
      class="kw">public void onSystemAddedToStore(@Nonnull Store<EntityStore> var1) {
         SpawnSuppressionController var2 = var1.getResource(this.spawnSuppressionControllerResourceType);
         Map var3 = var2.getSpawnSuppressorMap();
         var3.forEach(
            (var3x, var4) -> SpawnSuppressionSystems.suppressSpawns(
               this.chunkSuppressionQueueResourceType,
               this.spawnMarkerEntityComponentType,
               var3x,
               var4,
               var2,
               var1,
               var1.getExternalData().getWorld().getChunkStore()
            )
         );
      }

      @Override
      class="kw">public void onSystemRemovedFromStore(@Nonnull Store<EntityStore> var1) {
      }

      @Override
      class="kw">public void onSystemUnregistered() {
         this.eventRegistry.shutdownAndCleanup(true);
      }

      class="kw">private void onSpawnSuppressionsLoaded(@Nonnull LoadedAssetsEvent<String, SpawnSuppression, IndexedAssetMap<String, SpawnSuppression>> var1) {
         Map var2 = var1.getLoadedAssets();
         Universe.get().getWorlds().forEach((var2x, var3) -> var3.execute(() -> {
            World var3 = false;
            Store var4 = var3.getEntityStore().getStore();
            SpawnSuppressionController var5 = var4.getResource(this.spawnSuppressionControllerResourceType);
            Map var6 = var5.getSpawnSuppressorMap();

            for (SpawnSuppressorEntry var8 : var6.values()) {
               if (var2.containsKey(var8.getSuppressionId())) {
                  var3 = true;
                  break;
               }
            }

            if (var3) {
               this.rebuildSuppressionMap(var3, var4, var5);
            }
         }));
      }

      class="kw">private void onSpawnSuppressionsRemoved(@Nonnull RemovedAssetsEvent<String, SpawnSuppression, IndexedAssetMap<String, SpawnSuppression>> var1) {
         Set var2 = var1.getRemovedAssets();
         Universe.get().getWorlds().forEach((var2x, var3) -> var3.execute(() -> {
            World var3 = false;
            Store var4 = var3.getEntityStore().getStore();
            SpawnSuppressionController var5 = var4.getResource(this.spawnSuppressionControllerResourceType);
            Map var6 = var5.getSpawnSuppressorMap();

            for (SpawnSuppressorEntry var8 : var6.values()) {
               if (var2.contains(var8.getSuppressionId())) {
                  var3 = true;
                  break;
               }
            }

            if (var3) {
               this.rebuildSuppressionMap(var3, var4, var5);
            }
         }));
      }

      class="kw">private void rebuildSuppressionMap(@Nonnull World var1, @Nonnull Store<EntityStore> var2, @Nonnull SpawnSuppressionController var3) {
         SpawningPlugin.get().getLogger().at(Level.INFO).log("Rebuilding spawn suppression map for world %s", var1.getName());
         ChunkStore var4 = var1.getChunkStore();
         Store var5 = var4.getStore();
         Long2ObjectConcurrentHashMap var6 = var3.getChunkSuppressionMap();
         LongIterator var7 = var6.keySet().iterator();

         while (var7.hasNext()) {
            long var8 = (Long)var7.next();
            Ref var10 = var4.getChunkReference(var8);
            if (var10 != null) {
               var5.tryRemoveComponent(var10, this.chunkSuppressionEntryComponentType);
            }
         }

         var6.clear();
         var2.forEachEntityParallel(
            SpawnMarkerEntity.getComponentType(), (var0, var1x, var2x) -> var1x.getComponent(var0, SpawnMarkerEntity.getComponentType()).clearAllSuppressions()
         );
         Map var11 = var3.getSpawnSuppressorMap();
         var11.forEach(
            (var3x, var4x) -> SpawnSuppressionSystems.suppressSpawns(
               this.chunkSuppressionQueueResourceType,
               this.spawnMarkerEntityComponentType,
               var3x,
               var4x,
               var3,
               var2,
               var2.getExternalData().getWorld().getChunkStore()
            )
         );
      }
   }

   class="kw">public class="kw">static class Suppressor class="kw">extends RefSystem<EntityStore> {
      class="kw">private class="kw">final ComponentType<EntityStore, SpawnSuppressionComponent> spawnSuppressorComponentType;
      class="kw">private class="kw">final ResourceType<EntityStore, SpawnSuppressionController> spawnSuppressionControllerResourceType;
      class="kw">private class="kw">final ComponentType<EntityStore, SpawnMarkerEntity> spawnMarkerEntityComponentType;
      class="kw">private class="kw">final ResourceType<ChunkStore, ChunkSuppressionQueue> chunkSuppressionQueueResourceType;
      class="kw">private class="kw">final ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> spawnMarkerSpatialResourceType;
      class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentType = TransformComponent.getComponentType();
      class="kw">private class="kw">final ComponentType<EntityStore, UUIDComponent> uuidComponentType = UUIDComponent.getComponentType();
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public Suppressor(
         ComponentType<EntityStore, SpawnSuppressionComponent> var1,
         ResourceType<EntityStore, SpawnSuppressionController> var2,
         ComponentType<EntityStore, SpawnMarkerEntity> var3,
         ResourceType<ChunkStore, ChunkSuppressionQueue> var4,
         ResourceType<EntityStore, SpatialResource<Ref<EntityStore>, EntityStore>> var5
      ) {
         this.spawnSuppressorComponentType = var1;
         this.spawnSuppressionControllerResourceType = var2;
         this.spawnMarkerEntityComponentType = var3;
         this.chunkSuppressionQueueResourceType = var4;
         this.spawnMarkerSpatialResourceType = var5;
         this.query = Query.and(var1, this.transformComponentType, this.uuidComponentType);
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Nullable
      @Override
      class="kw">public SystemGroup<EntityStore> getGroup() {
         class="kw">return EntityModule.get().getPreClearMarkersGroup();
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         Archetype var5 = var3.getArchetype(var1);
         SpawnSuppressionComponent var6 = var3.getComponent(var1, this.spawnSuppressorComponentType);
         TransformComponent var7 = var4.getComponent(var1, this.transformComponentType);
         UUIDComponent var8 = var4.getComponent(var1, this.uuidComponentType);
         boolean var9 = var5.contains(FromPrefab.getComponentType()) || var5.contains(FromWorldGen.getComponentType());
         if (var2 == AddReason.SPAWN || var9) {
            SpawnSuppressionController var10 = var3.getResource(this.spawnSuppressionControllerResourceType);
            SpawnSuppressorEntry var11 = new SpawnSuppressorEntry(var6.getSpawnSuppression(), new Vector3d(var7.getPosition()));
            UUID var12 = var8.getUuid();
            SpawnSuppressorEntry var13 = var10.getSpawnSuppressorMap().put(var12, var11);
            if (var13 != null) {
               throw new IllegalStateException(String.format("A spawn suppressor with the ID %s is already registered.", var12));
            }

            SpawnSuppressionSystems.suppressSpawns(
               this.chunkSuppressionQueueResourceType,
               this.spawnMarkerEntityComponentType,
               var12,
               var11,
               var10,
               var3,
               var3.getExternalData().getWorld().getChunkStore()
            );
            var4.ensureComponent(var1, PrefabCopyableComponent.getComponentType());
         }
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         if (var2 == RemoveReason.REMOVE) {
            SpawnSuppressionController var5 = var3.getResource(this.spawnSuppressionControllerResourceType);
            UUIDComponent var6 = var4.getComponent(var1, this.uuidComponentType);
            Map var7 = var5.getSpawnSuppressorMap();
            UUID var8 = var6.getUuid();
            SpawnSuppressorEntry var9 = var7.remove(var8);
            String var10 = var9.getSuppressionId();
            SpawnSuppression var11 = SpawnSuppression.getAssetMap().getAsset(var10);
            if (var11 == null) {
               SpawningPlugin.get().getLogger().at(Level.WARNING).log("Spawn suppression config '%s' does not exist", var10);
            } else {
               double var12 = var11.getRadius();
               Vector3d var14 = var9.getPosition();
               int var15 = MathUtil.floor(var14.x - var12) >> 5;
               int var16 = MathUtil.floor(var14.z - var12) >> 5;
               int var17 = MathUtil.floor(var14.x + var12) >> 5;
               int var18 = MathUtil.floor(var14.z + var12) >> 5;
               ChunkStore var19 = var3.getExternalData().getWorld().getChunkStore();
               Store var20 = var19.getStore();
               Long2ObjectConcurrentHashMap var21 = var5.getChunkSuppressionMap();

               for (int var22 = var15; var22 <= var17; var22++) {
                  for (int var23 = var16; var23 <= var18; var23++) {
                     long var24 = ChunkUtil.indexChunk(var22, var23);
                     ChunkSuppressionEntry var26 = null;
                     ChunkSuppressionEntry var27 = var21.get(var24);
                     if (var27 != null) {
                        if (var27.containsOnly(var8)) {
                           var21.remove(var24);
                        } else {
                           List var28 = var27.getSuppressionSpans();
                           ObjectArrayList var29 = new ObjectArrayList();

                           for (ChunkSuppressionEntry.SuppressionSpan var31 : var28) {
                              if (!var31.getSuppressorId().equals(var8)) {
                                 var29.add(var31);
                              }
                           }

                           var26 = new ChunkSuppressionEntry(var29);
                           var21.put(var24, var26);
                        }

                        Ref var37 = var19.getChunkReference(var24);
                        if (var37 != null) {
                           ChunkSuppressionQueue var38 = var20.getResource(this.chunkSuppressionQueueResourceType);
                           if (var26 == null) {
                              var38.queueForRemove(var37);
                           } else {
                              var38.queueForAdd(var37, var26);
                           }

                           SpawningPlugin.get().getLogger().at(Level.FINEST).log("Queuing removal of suppression from chunk index %s, %s", var24, var10);
                        }
                     }
                  }
               }

               if (var11.isSuppressSpawnMarkers()) {
                  List var32 = SpatialResource.getThreadLocalReferenceList();
                  SpatialResource var33 = var3.getResource(this.spawnMarkerSpatialResourceType);
                  var33.getSpatialStructure().collect(var14, var12, var32);

                  for (int var34 = 0; var34 < var32.size(); var34++) {
                     Ref var25 = var32.get(var34);
                     SpawnMarkerEntity var35 = var4.getComponent(var25, this.spawnMarkerEntityComponentType);
                     var35.releaseSuppression(var8);
                     HytaleLogger.Api var36 = SpawningPlugin.get().getLogger().at(Level.FINEST);
                     if (var36.isEnabled()) {
                        var36.log("Releasing suppression of spawn marker %s", var4.getComponent(var25, this.uuidComponentType).getUuid());
                     }
                  }
               }
            }
         }
      }
   }
}