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

class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.ComponentType;
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.query.Query;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.iterator.SpiralIterator;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
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.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.spawning.world.ChunkEnvironmentSpawnData;
class="kw">import com.hypixel.hytale.server.spawning.world.WorldEnvironmentSpawnData;
class="kw">import com.hypixel.hytale.server.spawning.world.WorldNPCSpawnStat;
class="kw">import com.hypixel.hytale.server.spawning.world.component.ChunkSpawnData;
class="kw">import com.hypixel.hytale.server.spawning.world.component.ChunkSpawnedNPCData;
class="kw">import com.hypixel.hytale.server.spawning.world.component.WorldSpawnData;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
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 WorldSpawnTrackingSystem class="kw">extends RefSystem<EntityStore> {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static class="kw">final int COUNT_SPREAD_RADIUS = 3;
   @Nullable
   class="kw">private class="kw">final ComponentType<EntityStore, NPCEntity> npcComponentType = NPCEntity.getComponentType();
   class="kw">private class="kw">final ComponentType<EntityStore, TransformComponent> transformComponentType = TransformComponent.getComponentType();
   class="kw">private class="kw">final ResourceType<EntityStore, WorldSpawnData> worldSpawnDataResourceType;
   class="kw">private class="kw">final ComponentType<ChunkStore, ChunkSpawnData> chunkSpawnDataComponentType;
   class="kw">private class="kw">final ComponentType<ChunkStore, ChunkSpawnedNPCData> chunkSpawnedNPCDataComponentType;
   @Nonnull
   class="kw">private class="kw">final Query<EntityStore> query;

   class="kw">public WorldSpawnTrackingSystem(
      @Nonnull ResourceType<EntityStore, WorldSpawnData> var1,
      @Nonnull ComponentType<ChunkStore, ChunkSpawnData> var2,
      @Nonnull ComponentType<ChunkStore, ChunkSpawnedNPCData> var3
   ) {
      this.worldSpawnDataResourceType = var1;
      this.chunkSpawnDataComponentType = var2;
      this.chunkSpawnedNPCDataComponentType = var3;
      this.query = Query.and(this.npcComponentType, this.transformComponentType);
   }

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

   @Override
   class="kw">public void onEntityAdded(
      @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
   ) {
      NPCEntity var5 = var3.getComponent(var1, this.npcComponentType);
      assert var5 != null;
      boolean var6 = var5.updateSpawnTrackingState(true);
      if (!var6) {
         World var7 = var3.getExternalData().getWorld();
         WorldSpawnData var8 = var3.getResource(this.worldSpawnDataResourceType);
         class="kw">switch (var2) {
            case SPAWN:
               int var9 = var5.getEnvironment();
               if (!trackNPC(var9, var5.getSpawnRoleIndex(), var8, var7, var4)) {
                  class="kw">return;
               }

               ChunkStore var10 = var7.getChunkStore();
               Store var11 = var10.getStore();
               Vector3d var12 = var3.getComponent(var1, this.transformComponentType).getPosition();
               int var13 = ChunkUtil.chunkCoordinate(var12.x());
               int var14 = ChunkUtil.chunkCoordinate(var12.z());
               Ref var15 = var10.getChunkReference(ChunkUtil.indexChunk(var13, var14));
               double var16 = var15 != null
                  ? trackNewNPC(var15, var9, 1.0, this.chunkSpawnDataComponentType, this.chunkSpawnedNPCDataComponentType, var11)
                  : 1.0;
               if (var16 <= 0.0) {
                  class="kw">return;
               }

               SpiralIterator var18 = var8.getSpiralIterator();
               var18.init(var13, var14, 3);
               if (!var18.hasNext()) {
                  class="kw">return;
               }

               var18.next();
               int var19 = 0;
               int var20 = 0;

               while (var18.hasNext() && var16 > 0.0) {
                  var19++;
                  long var21 = var18.next();
                  var15 = var10.getChunkReference(var21);
                  if (var15 == null) {
                     var20++;
                  } else {
                     var16 = trackNewNPC(var15, var9, var16, this.chunkSpawnDataComponentType, this.chunkSpawnedNPCDataComponentType, var11);
                  }
               }

               if (var16 > 0.0) {
                  HytaleLogger.Api var27 = LOGGER.at(Level.FINE);
                  if (var27.isEnabled()) {
                     var27.log(
                        "Failed to spread %s of an NPC spawn to neighbouring chunks. Checked %s chunks, %s not in memory. Centered on chunk (%s, %s), spreading to other chunks with matching environment",
                        var16,
                        var19,
                        var20,
                        var13,
                        var14
                     );
                  }

                  List var22 = var8.getWorldEnvironmentSpawnData(var9).getChunkRefList();
                  Iterator var23 = var22.iterator();

                  while (var23.hasNext() && var16 > 0.0) {
                     var16 = trackNewNPC(var23.next(), var9, var16, this.chunkSpawnDataComponentType, this.chunkSpawnedNPCDataComponentType, var11);
                  }

                  if (var16 > 0.0 && var27.isEnabled()) {
                     WorldEnvironmentSpawnData var24 = var8.getWorldEnvironmentSpawnData(var9);
                     WorldNPCSpawnStat var25 = (WorldNPCSpawnStat)var24.getNpcStatMap().get(var5.getRoleIndex());
                     var27.log(
                        "Failed to spread %s of an NPC spawn across random chunks with matching environments (%s). NPC Type: %s. World environment exp: %s act: %s. Stat exp: %s act: %s",
                        var16,
                        Environment.getAssetMap().getAsset(var9).getId(),
                        NPCPlugin.get().getName(var5.getRoleIndex()),
                        var24.getExpectedNPCs(),
                        var24.getActualNPCs(),
                        var25.getExpected(),
                        var25.getActual()
                     );
                  }
               }

               var18.reset();
               break;
            case LOAD:
               trackNPC(var5.getEnvironment(), var5.getSpawnRoleIndex(), var8, var7, var4);
         }
      }
   }

   @Override
   class="kw">public void onEntityRemove(
      @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
   ) {
      NPCEntity var5 = var3.getComponent(var1, this.npcComponentType);
      assert var5 != null;
      boolean var6 = var5.updateSpawnTrackingState(false);
      if (var6) {
         WorldSpawnData var7 = var3.getResource(this.worldSpawnDataResourceType);
         class="kw">switch (var2) {
            case REMOVE:
            case BUILDER_TOOLS_UNDO:
               int var8 = var5.getEnvironment();
               if (!untrackNPC(var8, var5.getSpawnRoleIndex(), var7)) {
                  class="kw">return;
               }

               World var9 = var3.getExternalData().getWorld();
               ChunkStore var10 = var9.getChunkStore();
               Store var11 = var10.getStore();
               TransformComponent var12 = var3.getComponent(var1, this.transformComponentType);
               assert var12 != null;
               Vector3d var13 = var12.getPosition();
               int var14 = ChunkUtil.chunkCoordinate(var13.x());
               int var15 = ChunkUtil.chunkCoordinate(var13.z());
               Ref var16 = var10.getChunkReference(ChunkUtil.indexChunk(var14, var15));
               double var17 = var16 != null
                  ? untrackRemovedNPC(var16, var8, 1.0, this.chunkSpawnDataComponentType, this.chunkSpawnedNPCDataComponentType, var11)
                  : 1.0;
               if (var17 <= 0.0) {
                  class="kw">return;
               }

               SpiralIterator var19 = var7.getSpiralIterator();
               var19.init(var14, var15, 3);
               if (!var19.hasNext()) {
                  class="kw">return;
               }

               var19.next();

               while (var19.hasNext() && var17 > 0.0) {
                  long var20 = var19.next();
                  var16 = var10.getChunkReference(var20);
                  if (var16 != null) {
                     var17 = untrackRemovedNPC(var16, var8, var17, this.chunkSpawnDataComponentType, this.chunkSpawnedNPCDataComponentType, var11);
                  }
               }

               if (var17 > 0.0) {
                  HytaleLogger.Api var24 = LOGGER.at(Level.FINE);
                  if (var24.isEnabled()) {
                     var24.log("Failed to remove %s of a spread NPC spawn from neighbouring chunks, spreading to other chunks with matching environment", var17);
                  }

                  List var21 = var7.getWorldEnvironmentSpawnData(var8).getChunkRefList();
                  Iterator var22 = var21.iterator();

                  while (var22.hasNext() && var17 > 0.0) {
                     var17 = untrackRemovedNPC(var22.next(), var8, var17, this.chunkSpawnDataComponentType, this.chunkSpawnedNPCDataComponentType, var11);
                  }

                  if (var17 > 0.0 && var24.isEnabled()) {
                     var24.log("Failed to remove %s of an NPC spawn from random chunks with matching environments", var17);
                  }
               }

               var19.reset();
               break;
            case UNLOAD:
               untrackNPC(var5.getEnvironment(), var5.getSpawnRoleIndex(), var7);
         }
      }
   }

   class="kw">private class="kw">static boolean trackNPC(int var0, int var1, @Nonnull WorldSpawnData var2, @Nonnull World var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      if (!var2.trackNPC(var0, var1, 1, var3, var4)) {
         class="kw">return false;
      }

      HytaleLogger.Api var5 = LOGGER.at(Level.FINER);
      if (var5.isEnabled()) {
         var5.log("Track Spawn env=%s role=%s", getEnvironmentName(var0), NPCPlugin.get().getName(var1));
      }

      class="kw">return true;
   }

   class="kw">private class="kw">static boolean untrackNPC(int var0, int var1, @Nonnull WorldSpawnData var2) {
      if (!var2.untrackNPC(var0, var1, 1)) {
         class="kw">return false;
      }

      HytaleLogger.Api var3 = LOGGER.at(Level.FINER);
      if (var3.isEnabled()) {
         var3.log("Despawn env=%s role=%s", getEnvironmentName(var0), NPCPlugin.get().getName(var1));
      }

      class="kw">return true;
   }

   class="kw">private class="kw">static double trackNewNPC(
      @Nonnull Ref<ChunkStore> var0,
      int var1,
      double var2,
      @Nonnull ComponentType<ChunkStore, ChunkSpawnData> var4,
      @Nonnull ComponentType<ChunkStore, ChunkSpawnedNPCData> var5,
      @Nonnull Store<ChunkStore> var6
   ) {
      ChunkSpawnData var7 = var6.getComponent(var0, var4);
      if (var7 == null) {
         class="kw">return var2;
      }

      ChunkEnvironmentSpawnData var8 = (ChunkEnvironmentSpawnData)var7.getChunkEnvironmentSpawnDataMap().get(var1);
      if (var8 == null) {
         class="kw">return var2;
      }

      ChunkSpawnedNPCData var9 = var6.getComponent(var0, var5);
      assert var9 != null;
      double var10 = var9.getEnvironmentSpawnCount(var1);
      if (var8.isFullyPopulated(var10)) {
         class="kw">return var2;
      }

      WorldChunk var12 = var6.getComponent(var0, WorldChunk.getComponentType());
      assert var12 != null;
      var12.markNeedsSaving();
      double var13 = var8.getExpectedNPCs();
      double var15 = var13 - var10;
      if (var2 > var15) {
         HytaleLogger.Api var19 = LOGGER.at(Level.FINEST);
         if (var19.isEnabled()) {
            var19.log("Spreading %g to chunk %d with total capacity %g", var15, var12.getIndex(), var13);
         }

         var2 -= var15;
         var9.setEnvironmentSpawnCount(var1, var13);
         class="kw">return var2;
      } else {
         HytaleLogger.Api var17 = LOGGER.at(Level.FINEST);
         if (var17.isEnabled()) {
            var17.log("Spreading %g to chunk %d with total capacity %g", var2, var12.getIndex(), var13);
         }

         var9.setEnvironmentSpawnCount(var1, var10 + var2);
         class="kw">return 0.0;
      }
   }

   class="kw">private class="kw">static double untrackRemovedNPC(
      @Nonnull Ref<ChunkStore> var0,
      int var1,
      double var2,
      @Nonnull ComponentType<ChunkStore, ChunkSpawnData> var4,
      @Nonnull ComponentType<ChunkStore, ChunkSpawnedNPCData> var5,
      @Nonnull Store<ChunkStore> var6
   ) {
      ChunkSpawnData var7 = var6.getComponent(var0, var4);
      if (var7 == null) {
         class="kw">return var2;
      }

      ChunkEnvironmentSpawnData var8 = (ChunkEnvironmentSpawnData)var7.getChunkEnvironmentSpawnDataMap().get(var1);
      if (var8 == null) {
         class="kw">return var2;
      }

      ChunkSpawnedNPCData var9 = var6.getComponent(var0, var5);
      assert var9 != null;
      double var10 = var9.getEnvironmentSpawnCount(var1);
      if (var10 <= 0.0) {
         class="kw">return var2;
      }

      WorldChunk var12 = var6.getComponent(var0, WorldChunk.getComponentType());
      assert var12 != null;
      var12.markNeedsSaving();
      double var13 = var8.getExpectedNPCs();
      if (var10 < var2) {
         HytaleLogger.Api var17 = LOGGER.at(Level.FINEST);
         if (var17.isEnabled()) {
            var17.log("Spreading removal of %g to chunk %d with total capacity %g", var10, var12.getIndex(), var13);
         }

         var2 -= var10;
         var9.setEnvironmentSpawnCount(var1, 0.0);
         class="kw">return var2;
      } else {
         HytaleLogger.Api var15 = LOGGER.at(Level.FINEST);
         if (var15.isEnabled()) {
            var15.log("Spreading removal of %g to chunk %d with total capacity %g", var2, var12.getIndex(), var13);
         }

         var9.setEnvironmentSpawnCount(var1, var10 - var2);
         class="kw">return 0.0;
      }
   }

   class="kw">private class="kw">static String getEnvironmentName(int var0) {
      Environment var1 = Environment.getAssetMap().getAsset(var0);
      class="kw">return var1 != null ? var1.getId() : "<" + var0 + ">";
   }
}