class="kw">package com.hypixel.hytale.server.core.asset.type.blocktype.config;

class="kw">import com.hypixel.hytale.codec.codecs.EnumCodec;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
class="kw">import com.hypixel.hytale.protocol.BlockNeighbor;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.util.Map;
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 enum BlockFace {
   UP(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.Up, Vector3iUtil.UP),
   DOWN(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.Down, Vector3iUtil.DOWN),
   NORTH(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.North, Vector3iUtil.NORTH),
   EAST(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.East, Vector3iUtil.EAST),
   SOUTH(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.South, Vector3iUtil.SOUTH),
   WEST(BlockFace.FaceConnectionType.FLIP, BlockNeighbor.West, Vector3iUtil.WEST),
   UP_NORTH(BlockFace.FaceConnectionType.ROTATE_X, BlockNeighbor.UpNorth, UP, NORTH),
   UP_SOUTH(BlockFace.FaceConnectionType.ROTATE_X, BlockNeighbor.UpSouth, UP, SOUTH),
   UP_EAST(BlockFace.FaceConnectionType.ROTATE_Z, BlockNeighbor.UpEast, UP, EAST),
   UP_WEST(BlockFace.FaceConnectionType.ROTATE_Z, BlockNeighbor.UpWest, UP, WEST),
   DOWN_NORTH(BlockFace.FaceConnectionType.ROTATE_X, BlockNeighbor.DownNorth, DOWN, NORTH),
   DOWN_SOUTH(BlockFace.FaceConnectionType.ROTATE_X, BlockNeighbor.DownSouth, DOWN, SOUTH),
   DOWN_EAST(BlockFace.FaceConnectionType.ROTATE_Z, BlockNeighbor.DownEast, DOWN, EAST),
   DOWN_WEST(BlockFace.FaceConnectionType.ROTATE_Z, BlockNeighbor.DownWest, DOWN, WEST),
   NORTH_EAST(BlockFace.FaceConnectionType.ROTATE_Y, BlockNeighbor.NorthEast, NORTH, EAST),
   SOUTH_EAST(BlockFace.FaceConnectionType.ROTATE_Y, BlockNeighbor.SouthEast, SOUTH, EAST),
   SOUTH_WEST(BlockFace.FaceConnectionType.ROTATE_Y, BlockNeighbor.SouthWest, SOUTH, WEST),
   NORTH_WEST(BlockFace.FaceConnectionType.ROTATE_Y, BlockNeighbor.NorthWest, NORTH, WEST),
   UP_NORTH_EAST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.UpNorthEast, UP, NORTH, EAST),
   UP_SOUTH_EAST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.UpSouthEast, UP, SOUTH, EAST),
   UP_SOUTH_WEST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.UpSouthWest, UP, SOUTH, WEST),
   UP_NORTH_WEST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.UpNorthWest, UP, NORTH, WEST),
   DOWN_NORTH_EAST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.DownNorthEast, DOWN, NORTH, EAST),
   DOWN_SOUTH_EAST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.DownSouthEast, DOWN, SOUTH, EAST),
   DOWN_SOUTH_WEST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.DownSouthWest, DOWN, SOUTH, WEST),
   DOWN_NORTH_WEST(BlockFace.FaceConnectionType.ROTATE_ALL, BlockNeighbor.DownNorthWest, DOWN, NORTH, WEST);

   class="kw">public class="kw">static class="kw">final EnumCodec<BlockFace> CODEC = new EnumCodec<>(BlockFace.class);
   class="kw">public class="kw">static class="kw">final BlockFace[] VALUES = values();
   @Nonnull
   class="kw">private class="kw">static class="kw">final Map<Vector3ic, BlockFace> DIRECTION_MAP = new Object2ObjectOpenHashMap();
   class="kw">private class="kw">final BlockFace.FaceConnectionType faceConnectionType;
   @Nonnull
   class="kw">private class="kw">final BlockFace[] components;
   class="kw">private class="kw">final Vector3ic direction;
   class="kw">private class="kw">final BlockNeighbor blockNeighbor;
   class="kw">private BlockFace[] connectingFaces;
   class="kw">private Vector3ic[] connectingFaceOffsets;

   BlockFace(BlockFace.FaceConnectionType nullxx, BlockNeighbor nullxxx, Vector3ic nullxxxx) {
      this.faceConnectionType = nullxx;
      this.direction = nullxxxx;
      this.blockNeighbor = nullxxx;
      this.components = new BlockFace[0];
   }

   BlockFace(BlockFace.FaceConnectionType nullxx, BlockNeighbor nullxxx, @Nonnull BlockFace... nullxxxx) {
      this.faceConnectionType = nullxx;
      this.components = nullxxxx;

      for (BlockFace var9 : nullxxxx) {
         if (var9.components.length > 0) {
            throw new IllegalArgumentException("Only the base BlockFace's can be used as components to make other block faces");
         }
      }

      Vector3i var11 = new Vector3i();

      for (BlockFace var10 : nullxxxx) {
         var11.add(var10.direction);
      }

      this.direction = var11;
      this.blockNeighbor = nullxxx;
   }

   class="kw">public BlockFace.FaceConnectionType getFaceConnectionType() {
      class="kw">return this.faceConnectionType;
   }

   @Nonnull
   class="kw">public BlockFace[] getComponents() {
      class="kw">return this.components;
   }

   class="kw">public Vector3ic getDirection() {
      class="kw">return this.direction;
   }

   class="kw">public BlockFace[] getConnectingFaces() {
      class="kw">return this.connectingFaces;
   }

   class="kw">public Vector3ic[] getConnectingFaceOffsets() {
      class="kw">return this.connectingFaceOffsets;
   }

   @Nonnull
   class="kw">private BlockFace[] getConnectingFaces0() {
      class="kw">switch (this.faceConnectionType) {
         case FLIP:
            class="kw">return new BlockFace[]{flip(this)};
         case ROTATE_X:
            class="kw">return new BlockFace[]{
               rotate(this, Rotation.Ninety, Rotation.None, Rotation.None),
               rotate(this, Rotation.OneEighty, Rotation.None, Rotation.None),
               rotate(this, Rotation.TwoSeventy, Rotation.None, Rotation.None)
            };
         case ROTATE_Y:
            class="kw">return new BlockFace[]{
               rotate(this, Rotation.None, Rotation.Ninety, Rotation.None),
               rotate(this, Rotation.None, Rotation.OneEighty, Rotation.None),
               rotate(this, Rotation.None, Rotation.TwoSeventy, Rotation.None)
            };
         case ROTATE_Z:
            class="kw">return new BlockFace[]{
               rotate(this, Rotation.None, Rotation.None, Rotation.Ninety),
               rotate(this, Rotation.None, Rotation.None, Rotation.OneEighty),
               rotate(this, Rotation.None, Rotation.None, Rotation.TwoSeventy)
            };
         case ROTATE_ALL:
            class="kw">return new BlockFace[]{
               rotate(this, Rotation.Ninety, Rotation.None, Rotation.None),
               rotate(this, Rotation.OneEighty, Rotation.None, Rotation.None),
               rotate(this, Rotation.None, Rotation.Ninety, Rotation.None),
               rotate(this, Rotation.None, Rotation.OneEighty, Rotation.None),
               rotate(this, Rotation.None, Rotation.TwoSeventy, Rotation.None),
               rotate(this, Rotation.None, Rotation.None, Rotation.OneEighty),
               flip(this)
            };
         class="kw">default:
            throw new IllegalArgumentException("Unknown FaceConnectionType " + this.faceConnectionType);
      }
   }

   @Nonnull
   class="kw">private Vector3i directionTo(@Nonnull BlockFace var1) {
      Vector3i var2 = new Vector3i();
      if (this.direction.x() == -var1.direction.x()) {
         var2.x = this.direction.x();
      }

      if (this.direction.y() == -var1.direction.y()) {
         var2.y = this.direction.y();
      }

      if (this.direction.z() == -var1.direction.z()) {
         var2.z = this.direction.z();
      }

      class="kw">return var2;
   }

   class="kw">public class="kw">static BlockFace lookup(Vector3i var0) {
      class="kw">return DIRECTION_MAP.get(var0);
   }

   class="kw">public class="kw">static BlockFace rotate(@Nonnull BlockFace var0, @Nonnull Rotation var1, @Nonnull Rotation var2) {
      Vector3i var3 = Rotation.rotate(var0.direction, var1, var2);
      class="kw">return lookup(var3);
   }

   class="kw">public class="kw">static BlockFace rotate(@Nonnull BlockFace var0, @Nonnull Rotation var1, @Nonnull Rotation var2, @Nonnull Rotation var3) {
      Vector3i var4 = Rotation.rotate(var0.direction, var1, var2, var3);
      class="kw">return lookup(var4);
   }

   class="kw">public class="kw">static BlockFace flip(@Nonnull BlockFace var0) {
      Vector3i var1 = new Vector3i(var0.direction).mul(-1);
      class="kw">return lookup(var1);
   }

   class="kw">public BlockNeighbor toProtocolBlockNeighbor() {
      class="kw">return this.blockNeighbor;
   }

   @Nullable
   class="kw">public class="kw">static BlockFace fromProtocolFace(@Nonnull com.hypixel.hytale.protocol.BlockFace var0) {
      class="kw">return class="kw">switch (var0) {
         case Up -> UP;
         case Down -> DOWN;
         case North -> NORTH;
         case South -> SOUTH;
         case East -> EAST;
         case West -> WEST;
         case None -> null;
      };
   }

   @Nonnull
   class="kw">public class="kw">static com.hypixel.hytale.protocol.BlockFace toProtocolFace(@Nullable BlockFace var0) {
      if (var0 == null) {
         class="kw">return com.hypixel.hytale.protocol.BlockFace.None;
      }

      class="kw">return class="kw">switch (var0) {
         case UP -> com.hypixel.hytale.protocol.BlockFace.Up;
         case DOWN -> com.hypixel.hytale.protocol.BlockFace.Down;
         case NORTH -> com.hypixel.hytale.protocol.BlockFace.North;
         case EAST -> com.hypixel.hytale.protocol.BlockFace.East;
         case SOUTH -> com.hypixel.hytale.protocol.BlockFace.South;
         case WEST -> com.hypixel.hytale.protocol.BlockFace.West;
         class="kw">default -> throw new IllegalArgumentException("Invalid BlockFace");
      };
   }

   class="kw">static {
      for (BlockFace var3 : VALUES) {
         DIRECTION_MAP.put(var3.direction, var3);
      }

      for (BlockFace var8 : VALUES) {
         var8.connectingFaces = var8.getConnectingFaces0();
         var8.connectingFaceOffsets = new Vector3i[var8.connectingFaces.length];

         for (int var4 = 0; var4 < var8.connectingFaces.length; var4++) {
            var8.connectingFaceOffsets[var4] = var8.directionTo(var8.connectingFaces[var4]);
         }
      }
   }

   enum FaceConnectionType {
      FLIP,
      ROTATE_X,
      ROTATE_Y,
      ROTATE_Z,
      ROTATE_ALL;

      FaceConnectionType() {
      }
   }
}