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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Resource;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.iterator.SpiralIterator;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.core.modules.time.WorldTimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
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.spawning.SpawningPlugin;
class="kw">import com.hypixel.hytale.server.spawning.world.WorldEnvironmentSpawnData;
class="kw">import com.hypixel.hytale.server.spawning.world.manager.EnvironmentSpawnParameters;
class="kw">import com.hypixel.hytale.server.spawning.world.manager.WorldSpawnWrapper;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import java.util.ArrayDeque;
class="kw">import java.util.function.Consumer;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class WorldSpawnData class="kw">implements Resource<EntityStore> {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">final Int2ObjectMap<WorldEnvironmentSpawnData> worldEnvironmentSpawnData = new Int2ObjectOpenHashMap();
   class="kw">private class="kw">final ArrayDeque<WorldSpawnData.UnspawnableEntry> unspawnableProcessingQueue = new ArrayDeque<>();
   class="kw">private int actualNPCs;
   class="kw">private double expectedNPCs;
   class="kw">private double expectedNPCsInEmptyEnvironments;
   class="kw">private boolean unspawnable;
   class="kw">private int chunkCount;
   class="kw">private int segmentCount;
   class="kw">private int activeSpawnJobs;
   class="kw">private int trackedCountFromJobs;
   class="kw">private int totalSpawnJobBudgetUsed;
   class="kw">private int totalSpawnJobsCompleted;
   class="kw">private class="kw">final SpiralIterator spiralIterator = new SpiralIterator();

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

   class="kw">public class="kw">static ResourceType<EntityStore, WorldSpawnData> getResourceType() {
      class="kw">return SpawningPlugin.get().getWorldSpawnDataResourceType();
   }

   class="kw">public int getActualNPCs() {
      class="kw">return this.actualNPCs;
   }

   class="kw">public double getExpectedNPCs() {
      class="kw">return this.expectedNPCs;
   }

   class="kw">public double getExpectedNPCsInEmptyEnvironments() {
      class="kw">return this.expectedNPCsInEmptyEnvironments;
   }

   class="kw">public boolean isUnspawnable() {
      class="kw">return this.unspawnable;
   }

   class="kw">public void setUnspawnable(boolean var1) {
      this.unspawnable = var1;
   }

   class="kw">public int getChunkCount() {
      class="kw">return this.chunkCount;
   }

   class="kw">public void adjustChunkCount(int var1) {
      this.chunkCount += var1;
   }

   class="kw">public void adjustSegmentCount(int var1) {
      this.segmentCount += var1;
   }

   @Nonnull
   class="kw">public SpiralIterator getSpiralIterator() {
      class="kw">return this.spiralIterator;
   }

   class="kw">public double averageSegmentCount() {
      class="kw">return this.chunkCount == 0 ? 0.0 : (double)this.segmentCount / this.chunkCount;
   }

   class="kw">public int getActiveSpawnJobs() {
      class="kw">return this.activeSpawnJobs;
   }

   class="kw">public void adjustActiveSpawnJobs(int var1, int var2) {
      this.activeSpawnJobs += var1;
      this.trackedCountFromJobs += var2;
   }

   class="kw">public int getTrackedCountFromJobs() {
      class="kw">return this.trackedCountFromJobs;
   }

   class="kw">public int getTotalSpawnJobBudgetUsed() {
      class="kw">return this.totalSpawnJobBudgetUsed;
   }

   class="kw">public int getTotalSpawnJobsCompleted() {
      class="kw">return this.totalSpawnJobsCompleted;
   }

   class="kw">public void addCompletedSpawnJob(int var1) {
      this.totalSpawnJobBudgetUsed += var1;
      this.totalSpawnJobsCompleted++;
   }

   class="kw">public WorldEnvironmentSpawnData getWorldEnvironmentSpawnData(int var1) {
      class="kw">return (WorldEnvironmentSpawnData)this.worldEnvironmentSpawnData.get(var1);
   }

   @Nonnull
   class="kw">public WorldEnvironmentSpawnData getOrCreateWorldEnvironmentSpawnData(int var1, @Nonnull World var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      WorldTimeResource var4 = var3.getResource(WorldTimeResource.getResourceType());
      class="kw">return (WorldEnvironmentSpawnData)this.worldEnvironmentSpawnData.computeIfAbsent(var1, var2x -> {
         WorldEnvironmentSpawnData var3 = new WorldEnvironmentSpawnData(var2x);
         EnvironmentSpawnParameters var4 = SpawningPlugin.get().getWorldEnvironmentSpawnParameters(var2x);
         if (var4 == null) {
            Environment var8 = Environment.getAssetMap().getAsset(var2x);
            LOGGER.at(Level.WARNING).log("No environment data found for '%s' [%s] but used in chunk", var8 == null ? null : var8.getId(), var2x);
            class="kw">return var3;
         }

         for (WorldSpawnWrapper var6 : var4.getSpawnWrappers()) {
            var3.updateNPCs(var6, var2);
         }

         int var7 = var4.getMoonPhase();
         var3.recalculateWeight(var7);
         var3.resetUnspawnable();
         class="kw">return var3;
      });
   }

   class="kw">public int[] getWorldEnvironmentSpawnDataIndexes() {
      class="kw">return this.worldEnvironmentSpawnData.keySet().toIntArray();
   }

   class="kw">public void updateSpawnability() {
      this.unspawnable = true;
      ObjectIterator var1 = this.worldEnvironmentSpawnData.values().iterator();

      while (var1.hasNext()) {
         WorldEnvironmentSpawnData var2 = (WorldEnvironmentSpawnData)var1.next();
         if (!var2.isUnspawnable()) {
            this.unspawnable = false;
            break;
         }
      }
   }

   class="kw">public void forEachEnvironmentSpawnData(Consumer<WorldEnvironmentSpawnData> var1) {
      this.worldEnvironmentSpawnData.values().forEach(var1);
   }

   class="kw">public boolean trackNPC(int var1, int var2, int var3, @Nonnull World var4, @Nonnull ComponentAccessor<EntityStore> var5) {
      if (var2 >= 0 && var1 >= 0) {
         WorldEnvironmentSpawnData var6 = this.getOrCreateWorldEnvironmentSpawnData(var1, var4, var5);
         var6.trackSpawn(var2, var3);
         this.actualNPCs += var3;
         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

   class="kw">public boolean untrackNPC(int var1, int var2, int var3) {
      if (var1 >= 0 && var2 >= 0) {
         WorldEnvironmentSpawnData var4 = (WorldEnvironmentSpawnData)this.worldEnvironmentSpawnData.get(var1);
         if (var4 == null) {
            LOGGER.at(Level.WARNING)
               .log(
                  "Removing NPC %s from environment %s which is not contained in the world environment spawn data",
                  NPCPlugin.get().getName(var2),
                  Environment.getAssetMap().getAsset(var1).getId()
               );
            class="kw">return false;
         } else {
            var4.trackDespawn(var2, var3);
            this.actualNPCs -= var3;
            class="kw">return true;
         }
      } else {
         class="kw">return false;
      }
   }

   class="kw">public void recalculateWorldCount() {
      this.actualNPCs = 0;
      this.expectedNPCs = 0.0;
      this.expectedNPCsInEmptyEnvironments = 0.0;
      ObjectIterator var1 = this.worldEnvironmentSpawnData.values().iterator();

      while (var1.hasNext()) {
         WorldEnvironmentSpawnData var2 = (WorldEnvironmentSpawnData)var1.next();
         this.actualNPCs = this.actualNPCs + var2.getActualNPCs();
         if (var2.hasNPCs()) {
            this.expectedNPCs = this.expectedNPCs + var2.getExpectedNPCs();
         } else {
            this.expectedNPCsInEmptyEnvironments = this.expectedNPCsInEmptyEnvironments + var2.getExpectedNPCs();
         }
      }
   }

   class="kw">public void queueUnspawnableChunk(int var1, long var2) {
      this.unspawnableProcessingQueue.add(new WorldSpawnData.UnspawnableEntry(var1, var2));
   }

   class="kw">public boolean hasUnprocessedUnspawnableChunks() {
      class="kw">return !this.unspawnableProcessingQueue.isEmpty();
   }

   @Nullable
   class="kw">public WorldSpawnData.UnspawnableEntry nextUnspawnableChunk() {
      class="kw">return this.unspawnableProcessingQueue.isEmpty() ? null : this.unspawnableProcessingQueue.poll();
   }

   @Override
   class="kw">public Resource<EntityStore> clone() {
      throw new UnsupportedOperationException("Not implemented!");
   }

   class="kw">public class="kw">static class UnspawnableEntry {
      class="kw">private class="kw">final int environmentIndex;
      class="kw">private class="kw">final long chunkIndex;

      class="kw">public UnspawnableEntry(int var1, long var2) {
         this.environmentIndex = var1;
         this.chunkIndex = var2;
      }

      class="kw">public int getEnvironmentIndex() {
         class="kw">return this.environmentIndex;
      }

      class="kw">public long getChunkIndex() {
         class="kw">return this.chunkIndex;
      }
   }
}