class="kw">package com.hypixel.hytale.server.core.universe.world.connectedblocks;

class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockOperations;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.util.FillerBlockUtil;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIntPair;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
class="kw">import java.util.ArrayDeque;
class="kw">import java.util.Iterator;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.Optional;
class="kw">import java.util.Queue;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;
class="kw">import org.joml.Vector3ic;

class="kw">public class ConnectedBlocksUtil {
   class="kw">private class="kw">static class="kw">final int MAX_UPDATE_DEPTH = 3;

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

   class="kw">public class="kw">static void setConnectedBlockAndNotifyNeighbors(
      @Nonnull ChunkStore var0,
      int var1,
      @Nonnull RotationTuple var2,
      @Nonnull Vector3ic var3,
      @Nonnull Vector3ic var4,
      @Nonnull Ref<ChunkStore> var5,
      @Nonnull BlockSection var6
   ) {
      Vector3i var7 = new Vector3i(var4);
      BlockType var8 = BlockType.getAssetMap().getAsset(var1);
      if (var8 != null) {
         int var9 = var6.getFiller(var4.x(), var4.y(), var4.z());
         int var10 = 132;
         ConnectedBlockRuleSet var11 = var8.getConnectedBlockRuleSet();
         if (var11 != null && var9 == 0) {
            int var12 = var2.index();
            if (var11.getUpdateMode() == ConnectedBlockUpdateMode.UpdatePlaceUpdate) {
               updateNeighborsWithDepth(var0, var5, var7, var3, var10, true);
               var1 = var6.get(var7.x, var7.y, var7.z);
               var8 = BlockType.getAssetMap().getAsset(var1);
               if (var8 == null) {
                  class="kw">return;
               }

               var12 = var6.getRotationIndex(var7.x, var7.y, var7.z);
            }

            Optional var13 = getDesiredConnectedBlockType(var0, var7, var8, var12, var3, true);
            if (var13.isPresent() && (!var13.get().blockTypeKey().equals(var8.getId()) || var13.get().rotationIndex != var12)) {
               ConnectedBlocksUtil.ConnectedBlockResult var14 = var13.get();
               int var15 = BlockType.getAssetMap().getIndex(var14.blockTypeKey());
               int var16 = var14.rotationIndex();
               BlockOperations.setBlock(var0, var5, var7.x, var7.y, var7.z, var15, BlockType.getAssetMap().getAsset(var15), var16, 0, var10);
            }

            if (var11.getUpdateMode() == ConnectedBlockUpdateMode.IgnoreUpdates) {
               class="kw">return;
            }
         }

         updateNeighborsWithDepth(var0, var5, var7, var3, var10, false);
      }
   }

   class="kw">private class="kw">static void updateNeighborsWithDepth(
      @Nonnull ChunkStore var0, @Nonnull Ref<ChunkStore> var1, @Nonnull Vector3ic var2, @Nonnull Vector3ic var3, int var4, boolean var5
   ) {
      record QueueEntry(Vector3i coordinate, int depth) {
         QueueEntry {
         }
      }

      Queue var6 = new ArrayDeque<>();
      Set var7 = new ObjectOpenHashSet();
      var6.add(new QueueEntry(new Vector3i(var2), 0));

      label90:
      while (!var6.isEmpty()) {
         QueueEntry var8 = var6.poll();
         Vector3i var9 = var8.coordinate;
         int var10 = var8.depth;
         Map var11 = new Object2ObjectOpenHashMap();
         notifyNeighborsAndCollectChanges(var0, var9, var11, var3);
         Iterator var12 = var11.entrySet().iterator();

         while (true) {
            Vector3i var14;
            ConnectedBlocksUtil.ConnectedBlockResult var15;
            Ref var16;
            while (true) {
               while (true) {
                  if (!var12.hasNext()) {
                     class="kw">continue label90;
                  }

                  Entry var13 = (Entry<Vector3i, ConnectedBlocksUtil.ConnectedBlockResult>)var12.next();
                  var14 = var13.getKey();
                  var15 = var13.getValue();
                  if (var7.add(new Vector3i(var14)) && (var14.x != var9.x || var14.y != var9.y || var14.z != var9.z)) {
                     var16 = var1;
                     if (ChunkUtil.isSameChunkSection(var2.x(), var2.y(), var2.z(), var14.x, var14.y, var14.z)) {
                        break;
                     }

                     Ref var17 = var0.getChunkSectionReferenceAtBlock(var14.x, var14.y, var14.z);
                     if (var17 != null && var17.isValid()) {
                        var16 = var17;
                        break;
                     }
                  }
               }

               if (var5 && var14.equals(var2)) {
                  break;
               }

               int var25 = BlockType.getAssetMap().getIndex(var15.blockTypeKey());
               BlockType var18 = BlockType.getAssetMap().getAsset(var25);
               if (var18 != null) {
                  BlockOperations.setBlock(var0, var16, var14.x, var14.y, var14.z, var25, var18, var15.rotationIndex(), 0, var4);
                  break;
               }
            }

            for (Entry var27 : var15.getAdditionalConnectedBlocks().entrySet()) {
               Vector3i var19 = var27.getKey();
               ObjectIntPair var20 = var27.getValue();
               Vector3i var21 = new Vector3i(var14).add(var19);
               Ref var22 = var16;
               if (!ChunkUtil.isSameChunkSection(var14.x, var14.y, var14.z, var21.x, var21.y, var21.z)) {
                  Ref var23 = var0.getChunkSectionReferenceAtBlock(var21.x, var21.y, var21.z);
                  if (var23 == null || !var23.isValid()) {
                     class="kw">continue;
                  }

                  var22 = var23;
               }

               int var28 = BlockType.getAssetMap().getIndex((String)var20.first());
               BlockType var24 = BlockType.getAssetMap().getAsset(var28);
               if (var24 != null) {
                  BlockOperations.setBlock(var0, var22, var21.x, var21.y, var21.z, var28, var24, var20.rightInt(), 0, var4);
               }
            }

            if (var10 + 1 < 3) {
               var6.add(new QueueEntry(new Vector3i(var14), var10 + 1));
            }
         }
      }
   }

   class="kw">public class="kw">static void notifyNeighborsAndCollectChanges(
      @Nonnull ChunkStore var0, @Nonnull Vector3ic var1, @Nonnull Map<Vector3i, ConnectedBlocksUtil.ConnectedBlockResult> var2, @Nonnull Vector3ic var3
   ) {
      Vector3i var4 = new Vector3i(var1);
      Store var5 = var0.getStore();
      Vector3i var6 = new Vector3i(var1);
      Ref var7 = var0.getChunkSectionReferenceAtBlock(var1.x(), var1.y(), var1.z());

      for (int var8 = -1; var8 <= 1; var8++) {
         for (int var9 = -1; var9 <= 1; var9++) {
            for (int var10 = -1; var10 <= 1; var10++) {
               if (var8 != 0 || var10 != 0 || var9 != 0) {
                  var4.set(var1).add(var8, var10, var9);
                  if (!var2.containsKey(var4)) {
                     if (!ChunkUtil.isSameChunkSection(var6.x, var6.y, var6.z, var4.x, var4.y, var4.z)) {
                        var7 = var0.getChunkSectionReferenceAtBlock(var4.x(), var4.y(), var4.z());
                        var6.set(var4);
                     }

                     if (var7 != null && var7.isValid()) {
                        BlockSection var11 = var5.getComponent(var7, BlockSection.getComponentType());
                        if (var11 != null) {
                           int var12 = var11.get(var4.x, var4.y, var4.z);
                           BlockType var13 = BlockType.getAssetMap().getAsset(var12);
                           if (var13 != null) {
                              ConnectedBlockRuleSet var14 = var13.getConnectedBlockRuleSet();
                              if (var14 != null && !var14.onlyUpdateOnPlacement()) {
                                 int var15 = var11.getFiller(var4.x, var4.y, var4.z);
                                 int var16 = var11.getRotationIndex(var4.x, var4.y, var4.z);
                                 if (var15 != 0) {
                                    int var17 = var4.x - FillerBlockUtil.unpackX(var15);
                                    int var18 = var4.y - FillerBlockUtil.unpackY(var15);
                                    int var19 = var4.z - FillerBlockUtil.unpackZ(var15);
                                    var4.set(var17, var18, var19);
                                 }

                                 Optional var20 = getDesiredConnectedBlockType(var0, var4, var13, var16, var3, false);
                                 if (var20.isPresent() && (!var13.getId().equals(var20.get().blockTypeKey()) || var20.get().rotationIndex != var16)) {
                                    var2.put(new Vector3i(var4), var20.get());
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }

   @Nonnull
   class="kw">public class="kw">static Optional<ConnectedBlocksUtil.ConnectedBlockResult> getDesiredConnectedBlockType(
      @Nonnull ChunkStore var0, @Nonnull Vector3ic var1, @Nonnull BlockType var2, int var3, @Nonnull Vector3ic var4, boolean var5
   ) {
      ConnectedBlockRuleSet var6 = var2.getConnectedBlockRuleSet();
      class="kw">return var6 == null ? Optional.empty() : var6.getConnectedBlockType(var0, var1, var2, var3, var4, var5);
   }

   class="kw">public class="kw">static class="kw">final class ConnectedBlockResult {
      @Nonnull
      class="kw">private class="kw">final String blockTypeKey;
      class="kw">private class="kw">final int rotationIndex;
      @Nonnull
      class="kw">private class="kw">final Map<Vector3i, ObjectIntPair<String>> additionalConnectedBlocks = new Object2ObjectOpenHashMap();

      class="kw">public ConnectedBlockResult(@Nonnull String var1, int var2) {
         this.blockTypeKey = var1;
         this.rotationIndex = var2;
      }

      @Nonnull
      class="kw">public String blockTypeKey() {
         class="kw">return this.blockTypeKey;
      }

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

      @Nonnull
      class="kw">public Map<Vector3i, ObjectIntPair<String>> getAdditionalConnectedBlocks() {
         class="kw">return this.additionalConnectedBlocks;
      }

      class="kw">public void addAdditionalBlock(@Nonnull Vector3i var1, @Nonnull String var2, int var3) {
         this.additionalConnectedBlocks.put(var1, ObjectIntPair.of(var2, var3));
      }

      @Override
      class="kw">public boolean equals(@Nullable Object var1) {
         if (var1 == this) {
            class="kw">return true;
         } else if (var1 != null && var1.getClass() == this.getClass()) {
            ConnectedBlocksUtil.ConnectedBlockResult var2 = (ConnectedBlocksUtil.ConnectedBlockResult)var1;
            class="kw">return Objects.equals(this.blockTypeKey, var2.blockTypeKey)
               && this.rotationIndex == var2.rotationIndex
               && Objects.equals(this.additionalConnectedBlocks, var2.additionalConnectedBlocks);
         } else {
            class="kw">return false;
         }
      }

      @Override
      class="kw">public int hashCode() {
         class="kw">return Objects.hash(this.blockTypeKey, this.rotationIndex, this.additionalConnectedBlocks);
      }

      @Override
      class="kw">public String toString() {
         class="kw">return "ConnectedBlockResult[blockTypeKey="
            + this.blockTypeKey
            + ", rotationIndex="
            + this.rotationIndex
            + ", additionalConnectedBlocks="
            + this.additionalConnectedBlocks
            + "]";
      }
   }
}