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

class="kw">import com.hypixel.fastutil.ints.Int2ObjectConcurrentHashMap;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.component.Store;
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.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.npc.NPCPlugin;
class="kw">import com.hypixel.hytale.server.npc.entities.NPCEntity;
class="kw">import com.hypixel.hytale.server.spawning.SpawningPlugin;
class="kw">import com.hypixel.hytale.server.spawning.assets.spawns.config.RoleSpawnParameters;
class="kw">import com.hypixel.hytale.server.spawning.assets.spawns.config.WorldNPCSpawn;
class="kw">import com.hypixel.hytale.server.spawning.managers.SpawnManager;
class="kw">import com.hypixel.hytale.server.spawning.world.WorldEnvironmentSpawnData;
class="kw">import com.hypixel.hytale.server.spawning.world.component.SpawnJobData;
class="kw">import com.hypixel.hytale.server.spawning.world.component.WorldSpawnData;
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.ints.IntIterator;
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.ints.Int2ObjectMap.Entry;
class="kw">import it.unimi.dsi.fastutil.longs.Long2IntMap;
class="kw">import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import java.util.Iterator;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class WorldSpawnManager class="kw">extends SpawnManager<WorldSpawnWrapper, WorldNPCSpawn> {
   class="kw">protected class="kw">final Int2ObjectConcurrentHashMap<EnvironmentSpawnParameters> environmentSpawnParametersMap = new Int2ObjectConcurrentHashMap<>();
   class="kw">protected class="kw">final Long2IntMap npcEnvCombinations = new Long2IntOpenHashMap();
   class="kw">protected class="kw">final Int2ObjectMap<IntSet> npcTypesPerEnvironment = new Int2ObjectOpenHashMap();

   class="kw">public WorldSpawnManager() {
      this.npcEnvCombinations.defaultReturnValue(Integer.MIN_VALUE);
   }

   @Nullable
   class="kw">public WorldSpawnWrapper removeSpawnWrapper(int var1) {
      WorldSpawnWrapper var2 = (WorldSpawnWrapper)super.removeSpawnWrapper(var1);
      if (var2 == null) {
         class="kw">return null;
      }

      IntSet var3 = var2.getSpawn().getEnvironmentIds();
      IntIterator var4 = var3.iterator();

      while (var4.hasNext()) {
         int var5 = (Integer)var4.next();
         EnvironmentSpawnParameters var6 = this.environmentSpawnParametersMap.get(var5);
         if (var6 != null) {
            var6.getSpawnWrappers().remove(var2);
         }
      }

      var4 = var2.getRoles().keySet().iterator();

      while (var4.hasNext()) {
         int var9 = (Integer)var4.next();

         for (World var7 : Universe.get().getWorlds().values()) {
            onRoleRemoved(var7, var9, var3);
         }

         IntIterator var11 = var3.iterator();

         while (var11.hasNext()) {
            Integer var12 = (Integer)var11.next();
            this.removeCombination(var9, var12);
         }
      }

      class="kw">return var2;
   }

   class="kw">public boolean addSpawnWrapper(@Nonnull WorldSpawnWrapper var1) {
      WorldNPCSpawn var2 = var1.getSpawn();
      IndexedLookupTableAssetMap var3 = Environment.getAssetMap();
      IntSet var4 = var1.getSpawn().getEnvironmentIds();
      Int2ObjectMap var5 = var1.getRoles();
      int var6 = var1.getSpawnIndex();
      IntIterator var7 = var5.keySet().iterator();

      while (var7.hasNext()) {
         Integer var8 = (Integer)var7.next();
         IntIterator var9 = var4.iterator();

         while (var9.hasNext()) {
            Integer var10 = (Integer)var9.next();
            if (this.haveCombination(var8, var10)) {
               SpawningPlugin.get()
                  .getLogger()
                  .at(Level.SEVERE)
                  .log(
                     "Spawning Configuration %s can't be utilised: Combination NPC %s with Environment %s defined before in configuration %s",
                     var2.getId(),
                     NPCPlugin.get().getName(var8),
                     var3.getAsset(var10).getId(),
                     this.getCombination(var8, var10)
                  );
               class="kw">return false;
            }
         }
      }

      var7 = var4.iterator();

      while (var7.hasNext()) {
         Integer var16 = (Integer)var7.next();
         EnvironmentSpawnParameters var19 = this.environmentSpawnParametersMap.get(var16);
         if (var19 == null) {
            var19 = this.createEnvironmentSpawnParameters(var16, var3.getAsset(var16));
         }

         var19.getSpawnWrappers().add(var1);
      }

      for (World var17 : Universe.get().getWorlds().values()) {
         ObjectIterator var20 = var5.int2ObjectEntrySet().iterator();

         while (var20.hasNext()) {
            Entry var22 = (Entry<RoleSpawnParameters>)var20.next();
            int var11 = var22.getIntKey();
            RoleSpawnParameters var12 = (RoleSpawnParameters)var22.getValue();
            onRoleAdded(var17, var11, var4, var1, var12);
         }
      }

      var7 = var5.keySet().iterator();

      while (var7.hasNext()) {
         Integer var18 = (Integer)var7.next();
         IntIterator var21 = var4.iterator();

         while (var21.hasNext()) {
            Integer var23 = (Integer)var21.next();
            this.addCombination(var18, var23, var6);
         }
      }

      super.addSpawnWrapper(var1);
      class="kw">return true;
   }

   class="kw">public IntSet getRolesForEnvironment(int var1) {
      class="kw">return (IntSet)this.npcTypesPerEnvironment.get(var1);
   }

   @Nonnull
   class="kw">public EnvironmentSpawnParameters createEnvironmentSpawnParameters(int var1, @Nullable Environment var2) {
      EnvironmentSpawnParameters var3 = new EnvironmentSpawnParameters(var2 != null ? var2.getSpawnDensity() : 0.0);
      this.environmentSpawnParametersMap.put(var1, var3);
      class="kw">return var3;
   }

   class="kw">public EnvironmentSpawnParameters getEnvironmentSpawnParameters(int var1) {
      class="kw">return this.environmentSpawnParametersMap.get(var1);
   }

   class="kw">public void updateSpawnParameters(int var1, @Nullable Environment var2) {
      EnvironmentSpawnParameters var3 = this.getEnvironmentSpawnParameters(var1);
      if (var3 == null) {
         this.createEnvironmentSpawnParameters(var1, var2);
      } else {
         var3.setDensity(var2 != null ? var2.getSpawnDensity() : 0.0);
      }
   }

   class="kw">public void rebuildConfigurations(@Nullable IntSet var1) {
      if (var1 != null && !var1.isEmpty()) {
         untrackNPCs(var1);
         int var2 = 0;
         IntIterator var3 = var1.iterator();

         while (var3.hasNext()) {
            Integer var4 = (Integer)var3.next();
            this.removeSpawnWrapper(var4);
            WorldNPCSpawn var5 = WorldNPCSpawn.getAssetMap().getAssetOrDefault(var4, null);
            if (var5 != null && this.addSpawnWrapper(new WorldSpawnWrapper(var5))) {
               var2++;
            }
         }

         trackNPCs(var1);
         SpawningPlugin.get().getLogger().at(Level.INFO).log("Successfully rebuilt %s world spawn configurations", var2);
      }
   }

   class="kw">public class="kw">static void trackNPCs(@Nonnull IntSet var0) {
      Universe.get().getWorlds().forEach((var1, var2) -> var2.execute(() -> {
         World var2 = var2.getEntityStore().getStore();
         WorldSpawnData var3 = var2.getResource(WorldSpawnData.getResourceType());
         var2.forEachChunk(NPCEntity.getComponentType(), (var3x, var4) -> {
            for (int var5 = 0; var5 < var3x.size(); var5++) {
               NPCEntity var6 = var3x.getComponent(var5, NPCEntity.getComponentType());
               int var7 = var6.getSpawnConfiguration();
               if (var7 >= 0 && var0.contains(var7)) {
                  boolean var8 = var6.updateSpawnTrackingState(true);
                  if (!var8) {
                     var3.trackNPC(var6.getEnvironment(), var6.getRoleIndex(), 1, var2, var4);
                  }
               }
            }
         });
      }));
   }

   @Override
   class="kw">public void untrackNPCs(int var1) {
      if (var1 >= 0) {
         Universe.get()
            .getWorlds()
            .forEach((var1x, var2) -> var2.execute(() -> var2.getEntityStore().getStore().forEachChunk(NPCEntity.getComponentType(), (var2x, var3) -> {
               for (int var4 = 0; var4 < var2x.size(); var4++) {
                  NPCEntity var5 = var2x.getComponent(var4, NPCEntity.getComponentType());
                  if (var5.getSpawnConfiguration() == var1) {
                     untrackNPC(var2, var5);
                  }
               }
            })));
      }
   }

   class="kw">public class="kw">static void untrackNPCs(@Nonnull IntSet var0) {
      Universe.get()
         .getWorlds()
         .forEach((var1, var2) -> var2.execute(() -> var2.getEntityStore().getStore().forEachChunk(NPCEntity.getComponentType(), (var2x, var3) -> {
            for (int var4 = 0; var4 < var2x.size(); var4++) {
               NPCEntity var5 = var2x.getComponent(var4, NPCEntity.getComponentType());
               int var6 = var5.getSpawnConfiguration();
               if (var6 >= 0 && var0.contains(var6)) {
                  untrackNPC(var2, var5);
               }
            }
         })));
   }

   class="kw">public class="kw">static void onEnvironmentChanged() {
      Universe.get().getWorlds().forEach((var0, var1) -> var1.execute(() -> onEnvironmentChanged(var1)));
   }

   class="kw">private class="kw">static void untrackNPC(@Nonnull World var0, @Nonnull NPCEntity var1) {
      boolean var2 = var1.updateSpawnTrackingState(false);
      if (var2) {
         WorldSpawnData var3 = var0.getEntityStore().getStore().getResource(WorldSpawnData.getResourceType());
         var3.untrackNPC(var1.getEnvironment(), var1.getRoleIndex(), 1);
      }
   }

   class="kw">private class="kw">static void onEnvironmentChanged(@Nonnull World var0) {
      Store var1 = var0.getEntityStore().getStore();
      Store var2 = var0.getChunkStore().getStore();
      WorldTimeResource var3 = var1.getResource(WorldTimeResource.getResourceType());
      WorldSpawnData var4 = var1.getResource(WorldSpawnData.getResourceType());
      var4.forEachEnvironmentSpawnData(var3x -> {
         EnvironmentSpawnParameters var4 = SpawningPlugin.get().getWorldEnvironmentSpawnParameters(var3x.getEnvironmentIndex());
         if (var4 != null) {
            var3x.setDensity(var4.getSpawnDensity(), var2);

            for (WorldSpawnWrapper var6 : var4.getSpawnWrappers()) {
               var3x.updateNPCs(var6, var0);
            }

            int var7 = var3.getMoonPhase();
            var3x.recalculateWeight(var7);
            var3x.resetUnspawnable();
         } else {
            var3x.setDensity(0.0, var2);
            var3x.clearNPCs();
         }
      });
      var4.recalculateWorldCount();
   }

   class="kw">private class="kw">static void onRoleRemoved(@Nonnull World var0, int var1, @Nonnull IntSet var2) {
      var0.execute(() -> {
         var0.getChunkStore().getStore().forEachEntityParallel(SpawnJobData.getComponentType(), (var1x, var2x, var3x) -> {
            SpawnJobData var4 = var2x.getComponent(var1x, SpawnJobData.getComponentType());
            assert var4 != null;
            if (var4.getRoleIndex() == var1) {
               var4.terminate();
            }
         });
         Store var3 = var0.getEntityStore().getStore();
         WorldSpawnData var4 = var3.getResource(WorldSpawnData.getResourceType());
         Iterator var5 = var2.iterator();

         while (var5.hasNext()) {
            int var6 = (Integer)var5.next();
            WorldEnvironmentSpawnData var7 = var4.getWorldEnvironmentSpawnData(var6);
            if (var7 != null) {
               var7.removeNPC(var1, var3);
            }
         }
      });
   }

   class="kw">private class="kw">static void onRoleAdded(@Nonnull World var0, int var1, @Nonnull IntSet var2, WorldSpawnWrapper var3, @Nonnull RoleSpawnParameters var4) {
      var0.execute(() -> {
         Store var5 = var0.getEntityStore().getStore();
         WorldSpawnData var6 = var5.getResource(WorldSpawnData.getResourceType());
         Iterator var7 = var2.iterator();

         while (var7.hasNext()) {
            int var8 = (Integer)var7.next();
            var6.getOrCreateWorldEnvironmentSpawnData(var8, var0, var5).addNPC(var1, var3, var4, var0, var5);
         }

         onEnvironmentChanged();
      });
   }

   class="kw">private class="kw">static long combinedIndex(int var0, int var1) {
      class="kw">return ((long)var0 << 32) + var1;
   }

   class="kw">private boolean haveCombination(int var1, int var2) {
      class="kw">return this.npcEnvCombinations.containsKey(combinedIndex(var1, var2));
   }

   class="kw">private void addCombination(int var1, int var2, int var3) {
      this.npcEnvCombinations.put(combinedIndex(var1, var2), var3);
      ((IntSet)this.npcTypesPerEnvironment.computeIfAbsent(var2, var0 -> new IntOpenHashSet())).add(var1);
   }

   class="kw">private void removeCombination(int var1, int var2) {
      this.npcEnvCombinations.remove(combinedIndex(var1, var2));
      ((IntSet)this.npcTypesPerEnvironment.get(var2)).remove(var1);
   }

   class="kw">private String getCombination(int var1, int var2) {
      class="kw">return WorldNPCSpawn.getAssetMap().getAsset(this.npcEnvCombinations.get(combinedIndex(var1, var2))).getId();
   }
}