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

class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
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.Rotation;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.connectedblocks.ConnectedBlockRuleSet;
class="kw">import com.hypixel.hytale.server.core.universe.world.connectedblocks.ConnectedBlocksUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
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.Object2IntMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIntImmutablePair;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIntPair;
class="kw">import java.util.Optional;
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 StairConnectedBlockRuleSet class="kw">extends ConnectedBlockRuleSet class="kw">implements StairLikeConnectedBlockRuleSet {
   @Nonnull
   class="kw">public class="kw">static class="kw">final String DEFAULT_MATERIAL_NAME = "Stair";
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<StairConnectedBlockRuleSet> CODEC = BuilderCodec.builder(StairConnectedBlockRuleSet.class, StairConnectedBlockRuleSet::new)
      .append(new KeyedCodec<>("Straight", ConnectedBlockOutput.CODEC), (var0, var1) -> var0.straight = var1, var0 -> var0.straight)
      .addValidator(Validators.nonNull())
      .add()
      .<ConnectedBlockOutput>append(
         new KeyedCodec<>("Corner_Left", ConnectedBlockOutput.CODEC), (var0, var1) -> var0.cornerLeft = var1, var0 -> var0.cornerLeft
      )
      .addValidator(Validators.nonNull())
      .add()
      .<ConnectedBlockOutput>append(
         new KeyedCodec<>("Corner_Right", ConnectedBlockOutput.CODEC), (var0, var1) -> var0.cornerRight = var1, var0 -> var0.cornerRight
      )
      .addValidator(Validators.nonNull())
      .add()
      .append(
         new KeyedCodec<>("Inverted_Corner_Left", ConnectedBlockOutput.CODEC), (var0, var1) -> var0.invertedCornerLeft = var1, var0 -> var0.invertedCornerLeft
      )
      .add()
      .append(
         new KeyedCodec<>("Inverted_Corner_Right", ConnectedBlockOutput.CODEC),
         (var0, var1) -> var0.invertedCornerRight = var1,
         var0 -> var0.invertedCornerRight
      )
      .add()
      .append(new KeyedCodec<>("MaterialName", Codec.STRING), (var0, var1) -> var0.materialName = var1, var0 -> var0.materialName)
      .add()
      .build();
   class="kw">protected Object2IntMap<StairConnectedBlockRuleSet.StairType> stairTypeToBlockId;
   class="kw">private ConnectedBlockOutput straight;
   class="kw">private ConnectedBlockOutput cornerLeft;
   class="kw">private ConnectedBlockOutput cornerRight;
   class="kw">private ConnectedBlockOutput invertedCornerLeft;
   class="kw">private ConnectedBlockOutput invertedCornerRight;
   class="kw">private String materialName = "Stair";
   class="kw">private Int2ObjectMap<StairConnectedBlockRuleSet.StairType> blockIdToStairType;

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

   @Nullable
   class="kw">protected class="kw">static ObjectIntPair<StairConnectedBlockRuleSet.StairType> getStairData(@Nonnull ChunkStore var0, @Nonnull Vector3i var1, @Nullable String var2) {
      Store var3 = var0.getStore();
      Ref var4 = var0.getChunkSectionReferenceAtBlock(var1.x, var1.y, var1.z);
      if (var4 != null && var4.isValid()) {
         BlockSection var5 = var3.getComponent(var4, BlockSection.getComponentType());
         if (var5 == null) {
            class="kw">return null;
         }

         int var6 = var5.getFiller(var1.x, var1.y, var1.z);
         if (var6 != 0) {
            class="kw">return null;
         }

         int var7 = var5.get(var1.x, var1.y, var1.z);
         BlockType var8 = BlockType.getAssetMap().getAsset(var7);
         if (var8 == null) {
            class="kw">return null;
         }

         if (var8.getConnectedBlockRuleSet() class="kw">instanceof StairLikeConnectedBlockRuleSet var10) {
            String var11 = var10.getMaterialName();
            if (var2 != null && var11 != null && !var2.equals(var11)) {
               class="kw">return null;
            }

            StairConnectedBlockRuleSet.StairType var12 = var10.getStairType(var7);
            if (var12 == null) {
               class="kw">return null;
            }

            int var13 = var5.getRotationIndex(var1.x, var1.y, var1.z);
            class="kw">return new ObjectIntImmutablePair(var12, var13);
         } else {
            class="kw">return null;
         }
      } else {
         class="kw">return null;
      }
   }

   @Nullable
   class="kw">protected class="kw">static StairConnectedBlockRuleSet.StairConnection getCornerConnection(
      @Nonnull ChunkStore var0,
      @Nonnull StairLikeConnectedBlockRuleSet var1,
      @Nonnull Vector3ic var2,
      @Nonnull Vector3i var3,
      int var4,
      @Nonnull Rotation var5,
      boolean var6,
      int var7
   ) {
      StairConnectedBlockRuleSet.StairConnection var8 = null;
      var3.set(Vector3iUtil.NORTH).mul(var7);
      var5.rotateY(var3, var3);
      var3.add(var2.x(), var2.y(), var2.z());
      ObjectIntPair var9 = getStairData(var0, var3, var1.getMaterialName());
      if (var9 == null && var7 > 1) {
         var3.set(Vector3iUtil.NORTH).mul(var7 + 1);
         var5.rotateY(var3, var3);
         var3.add(var2.x(), var2.y(), var2.z());
         var9 = getStairData(var0, var3, var1.getMaterialName());
         if (var9 != null && var9.first() == StairConnectedBlockRuleSet.StairType.STRAIGHT) {
            var9 = null;
         }
      }

      if (var9 != null) {
         StairConnectedBlockRuleSet.StairType var10 = (StairConnectedBlockRuleSet.StairType)var9.left();
         RotationTuple var11 = RotationTuple.get(var9.rightInt());
         Rotation var12 = var11.yaw();
         boolean var13 = var11.pitch() != Rotation.None;
         if (var13) {
            var12 = var12.flip();
         }

         if (canConnectTo(var5, var12, var6, var13)) {
            var3.set(Vector3iUtil.SOUTH);
            var12.rotateY(var3, var3);
            var3.add(var2);
            ObjectIntPair var14 = getStairData(var0, var3, var1.getMaterialName());
            if (var14 == null || var14.rightInt() != var4) {
               var8 = getConnection(var5, var12, var10, false, var6);
            }
         }
      }

      class="kw">return var8;
   }

   @Nullable
   class="kw">protected class="kw">static StairConnectedBlockRuleSet.StairConnection getInvertedCornerConnection(
      @Nonnull ChunkStore var0,
      @Nonnull StairLikeConnectedBlockRuleSet var1,
      @Nonnull Vector3ic var2,
      @Nonnull Vector3i var3,
      @Nonnull Rotation var4,
      boolean var5
   ) {
      StairConnectedBlockRuleSet.StairConnection var6 = null;
      var3.set(Vector3iUtil.SOUTH);
      var4.rotateY(var3, var3);
      var3.add(var2);
      ObjectIntPair var7 = getStairData(var0, var3, var1.getMaterialName());
      if (var7 != null) {
         StairConnectedBlockRuleSet.StairType var8 = (StairConnectedBlockRuleSet.StairType)var7.left();
         RotationTuple var9 = RotationTuple.get(var7.rightInt());
         Rotation var10 = var9.yaw();
         boolean var11 = var9.pitch() != Rotation.None;
         if (var11) {
            var10 = var10.flip();
         }

         if (canConnectTo(var4, var10, var5, var11)) {
            var6 = getConnection(var4, var10, var8, true, var5);
         }
      }

      class="kw">return var6;
   }

   class="kw">private class="kw">static boolean canConnectTo(@Nonnull Rotation var0, @Nonnull Rotation var1, boolean var2, boolean var3) {
      class="kw">return var3 == var2 && var1 != var0 && var1.add(Rotation.OneEighty) != var0;
   }

   @Nullable
   class="kw">private class="kw">static StairConnectedBlockRuleSet.StairConnection getConnection(
      @Nonnull Rotation var0, @Nonnull Rotation var1, @Nonnull StairConnectedBlockRuleSet.StairType var2, boolean var3, boolean var4
   ) {
      if (var1 == var0.add(Rotation.Ninety)
         && var2 != StairConnectedBlockRuleSet.StairType.invertedCorner(var4 ^ var3)
         && var2 != StairConnectedBlockRuleSet.StairType.corner(var4 ^ !var3)) {
         class="kw">return StairConnectedBlockRuleSet.StairConnection.CORNER_LEFT;
      } else {
         class="kw">return var1 == var0.subtract(Rotation.Ninety)
               && var2 != StairConnectedBlockRuleSet.StairType.invertedCorner(var4 ^ !var3)
               && var2 != StairConnectedBlockRuleSet.StairType.corner(var4 ^ var3)
            ? StairConnectedBlockRuleSet.StairConnection.CORNER_RIGHT
            : null;
      }
   }

   @Override
   class="kw">public boolean onlyUpdateOnPlacement() {
      class="kw">return false;
   }

   @Override
   class="kw">public void updateCachedBlockTypes(@Nonnull BlockType var1, @Nonnull BlockTypeAssetMap<String, BlockType> var2) {
      int var3 = var2.getIndex(var1.getId());
      Int2ObjectMap var4 = new Int2ObjectOpenHashMap();
      Object2IntMap var5 = new Object2IntOpenHashMap();
      var5.defaultReturnValue(var3);
      ConnectedBlockOutput[] var6 = new ConnectedBlockOutput[]{
         this.straight, this.cornerLeft, this.cornerRight, this.invertedCornerLeft, this.invertedCornerRight
      };
      StairConnectedBlockRuleSet.StairType[] var7 = StairConnectedBlockRuleSet.StairType.VALUES;

      for (int var8 = 0; var8 < var6.length; var8++) {
         ConnectedBlockOutput var9 = var6[var8];
         if (var9 != null) {
            int var10 = var9.resolve(var1, var2);
            if (var10 != -1) {
               var4.put(var10, var7[var8]);
               var5.put(var7[var8], var10);
            }
         }
      }

      this.blockIdToStairType = var4;
      this.stairTypeToBlockId = var5;
   }

   @Override
   class="kw">public StairConnectedBlockRuleSet.StairType getStairType(int var1) {
      class="kw">return (StairConnectedBlockRuleSet.StairType)this.blockIdToStairType.get(var1);
   }

   @Nullable
   @Override
   class="kw">public String getMaterialName() {
      class="kw">return this.materialName;
   }

   @Nullable
   class="kw">public BlockType getStairBlockType(@Nonnull StairConnectedBlockRuleSet.StairType var1) {
      if (this.stairTypeToBlockId == null) {
         class="kw">return null;
      }

      int var2 = this.stairTypeToBlockId.getInt(var1);
      class="kw">return BlockType.getAssetMap().getAsset(var2);
   }

   @Nonnull
   @Override
   class="kw">public Optional<ConnectedBlocksUtil.ConnectedBlockResult> getConnectedBlockType(
      @Nonnull ChunkStore var1, @Nonnull Vector3ic var2, @Nonnull BlockType var3, int var4, @Nonnull Vector3ic var5, boolean var6
   ) {
      RotationTuple var7 = RotationTuple.get(var4);
      Rotation var8 = var7.yaw();
      Rotation var9 = var7.pitch();
      boolean var10 = var9 != Rotation.None;
      if (var10) {
         var8 = var8.flip();
      }

      Vector3i var11 = new Vector3i();
      StairConnectedBlockRuleSet.StairType var12 = StairConnectedBlockRuleSet.StairType.STRAIGHT;
      StairConnectedBlockRuleSet.StairConnection var13 = getInvertedCornerConnection(var1, this, var2, var11, var8, var10);
      if (var13 != null) {
         var12 = var13.getStairType(true);
      }

      StairConnectedBlockRuleSet.StairConnection var14 = getCornerConnection(var1, this, var2, var11, var4, var8, var10, 1);
      if (var14 != null) {
         var12 = var14.getStairType(false);
      }

      if (var10) {
         var12 = class="kw">switch (var12) {
            case CORNER_LEFT -> StairConnectedBlockRuleSet.StairType.CORNER_RIGHT;
            case CORNER_RIGHT -> StairConnectedBlockRuleSet.StairType.CORNER_LEFT;
            case INVERTED_CORNER_LEFT -> StairConnectedBlockRuleSet.StairType.INVERTED_CORNER_RIGHT;
            case INVERTED_CORNER_RIGHT -> StairConnectedBlockRuleSet.StairType.INVERTED_CORNER_LEFT;
            class="kw">default -> var12;
         };
      }

      int var15 = this.stairTypeToBlockId.getInt(var12);
      BlockType var16 = BlockType.getAssetMap().getAsset(var15);
      if (var16 == null) {
         class="kw">return Optional.empty();
      }

      String var17 = var16.getId();
      class="kw">return Optional.of(new ConnectedBlocksUtil.ConnectedBlockResult(var17, var4));
   }

   @Nullable
   @Override
   class="kw">public com.hypixel.hytale.protocol.ConnectedBlockRuleSet toPacket(@Nonnull BlockTypeAssetMap<String, BlockType> var1) {
      class="kw">return this.toProtocol(var1);
   }

   @Nonnull
   class="kw">public com.hypixel.hytale.protocol.StairConnectedBlockRuleSet toProtocol(@Nonnull BlockTypeAssetMap<String, BlockType> var1) {
      com.hypixel.hytale.protocol.StairConnectedBlockRuleSet var2 = new com.hypixel.hytale.protocol.StairConnectedBlockRuleSet();
      var2.straightBlockId = this.getBlockIdForStairType(StairConnectedBlockRuleSet.StairType.STRAIGHT, var1);
      var2.cornerLeftBlockId = this.getBlockIdForStairType(StairConnectedBlockRuleSet.StairType.CORNER_LEFT, var1);
      var2.cornerRightBlockId = this.getBlockIdForStairType(StairConnectedBlockRuleSet.StairType.CORNER_RIGHT, var1);
      var2.invertedCornerLeftBlockId = this.getBlockIdForStairType(StairConnectedBlockRuleSet.StairType.INVERTED_CORNER_LEFT, var1);
      var2.invertedCornerRightBlockId = this.getBlockIdForStairType(StairConnectedBlockRuleSet.StairType.INVERTED_CORNER_RIGHT, var1);
      var2.materialName = this.materialName;
      class="kw">return var2;
   }

   class="kw">private int getBlockIdForStairType(@Nonnull StairConnectedBlockRuleSet.StairType var1, @Nonnull BlockTypeAssetMap<String, BlockType> var2) {
      BlockType var3 = this.getStairBlockType(var1);
      class="kw">return var3 == null ? -1 : var2.getIndex(var3.getId());
   }

   class="kw">protected enum StairConnection {
      CORNER_LEFT,
      CORNER_RIGHT;

      StairConnection() {
      }

      @Nonnull
      class="kw">public StairConnectedBlockRuleSet.StairType getStairType(boolean var1) {
         class="kw">return class="kw">switch (this) {
            case CORNER_LEFT -> var1 ? StairConnectedBlockRuleSet.StairType.INVERTED_CORNER_LEFT : StairConnectedBlockRuleSet.StairType.CORNER_LEFT;
            case CORNER_RIGHT -> var1 ? StairConnectedBlockRuleSet.StairType.INVERTED_CORNER_RIGHT : StairConnectedBlockRuleSet.StairType.CORNER_RIGHT;
         };
      }
   }

   class="kw">public enum StairType {
      STRAIGHT,
      CORNER_LEFT,
      CORNER_RIGHT,
      INVERTED_CORNER_LEFT,
      INVERTED_CORNER_RIGHT;

      class="kw">private class="kw">static class="kw">final StairConnectedBlockRuleSet.StairType[] VALUES = values();

      StairType() {
      }

      @Nonnull
      class="kw">public class="kw">static StairConnectedBlockRuleSet.StairType corner(boolean var0) {
         class="kw">return var0 ? CORNER_RIGHT : CORNER_LEFT;
      }

      @Nonnull
      class="kw">public class="kw">static StairConnectedBlockRuleSet.StairType invertedCorner(boolean var0) {
         class="kw">return var0 ? INVERTED_CORNER_RIGHT : INVERTED_CORNER_LEFT;
      }

      class="kw">public boolean isCorner() {
         class="kw">return this == CORNER_LEFT || this == CORNER_RIGHT;
      }

      class="kw">public boolean isInvertedCorner() {
         class="kw">return this == INVERTED_CORNER_LEFT || this == INVERTED_CORNER_RIGHT;
      }

      class="kw">public boolean isLeft() {
         class="kw">return this == CORNER_LEFT || this == INVERTED_CORNER_LEFT;
      }

      class="kw">public boolean isRight() {
         class="kw">return this == CORNER_RIGHT || this == INVERTED_CORNER_RIGHT;
      }
   }
}