class="kw">package com.hypixel.hytale.server.core.prefab.selection.mask;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.function.FunctionCodec;
class="kw">import com.hypixel.hytale.common.map.IWeightedMap;
class="kw">import com.hypixel.hytale.common.map.WeightedMap;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
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.asset.type.buildertool.config.BlockTypeListAsset;
class="kw">import com.hypixel.hytale.server.core.util.FillerBlockUtil;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Random;
class="kw">import java.util.logging.Level;
class="kw">import java.util.regex.Pattern;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BlockPattern {
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">public class="kw">static class="kw">final Codec<BlockPattern> CODEC = new FunctionCodec<>(Codec.STRING, BlockPattern::parse, BlockPattern::toString);
   class="kw">public class="kw">static class="kw">final BlockPattern EMPTY = new BlockPattern(parseBlockPattern("Empty"));
   class="kw">public class="kw">static class="kw">final BlockPattern[] EMPTY_ARRAY = new BlockPattern[0];
   class="kw">private class="kw">static class="kw">final Pattern FILLER_TEMP_REMOVER_PATTERN = Pattern.compile("(Filler=-?\\d+),(-?\\d+),(-?\\d+)");
   class="kw">private class="kw">static class="kw">final String BLOCK_SEPARATOR = ",";
   class="kw">private class="kw">static class="kw">final String ALT_BLOCK_SEPARATOR = ";";
   class="kw">public class="kw">static class="kw">final String CHANCE_SUFFIX = "%";
   class="kw">private class="kw">static class="kw">final double DEFAULT_CHANCE = 100.0;
   class="kw">private class="kw">final IWeightedMap<String> weightedMap;
   class="kw">private class="kw">final class="kw">transient String toString0;
   class="kw">private IWeightedMap<Integer> resolvedWeightedMap;
   class="kw">private IWeightedMap<BlockPattern.BlockEntry> resolvedWeightedMapBtk;
   class="kw">private boolean hasInvalidBlocks;

   class="kw">public BlockPattern(IWeightedMap<String> var1) {
      this.weightedMap = var1;
      this.toString0 = this.toString0();
   }

   class="kw">public Integer[] getResolvedKeys() {
      this.resolve();
      class="kw">return this.resolvedWeightedMap.internalKeys();
   }

   class="kw">public void resolve() {
      if (this.resolvedWeightedMap == null) {
         WeightedMap.Builder var1 = WeightedMap.builder(ArrayUtil.EMPTY_INTEGER_ARRAY);
         WeightedMap.Builder var2 = WeightedMap.builder(new BlockPattern.BlockEntry[0]);
         this.weightedMap.forEachEntry((var3, var4) -> {
            int var6 = parseBlock(var3);
            if (var6 == 0) {
               String var7 = var3.contains("|") ? var3.substring(0, var3.indexOf(124)) : var3;
               if (!var7.equalsIgnoreCase("Empty")) {
                  this.hasInvalidBlocks = true;
               }
            }

            BlockPattern.BlockEntry var13 = tryParseBlockTypeKey(var3);
            BlockType var8 = BlockType.getAssetMap().getAsset(var6);
            if (var8 != null && var8.getBlockListAssetId() != null) {
               BlockTypeListAsset var9 = BlockTypeListAsset.getAssetMap().getAsset(var8.getBlockListAssetId());
               if (var9 != null && var9.getBlockPattern() != null) {
                  for (String var11 : var9.getBlockTypeKeys()) {
                     int var12 = BlockType.getAssetMap().getIndex(var11);
                     if (var12 == Integer.MIN_VALUE) {
                        LOGGER.at(Level.WARNING).log("BlockTypeList '%s' contains invalid block '%s' - skipping", var8.getBlockListAssetId(), var11);
                     } else {
                        var1.put(var12, var4 / var9.getBlockTypeKeys().size());
                     }
                  }

                  class="kw">return;
               }
            }

            var1.put(var6, var4);
            if (var13 != null) {
               var2.put(var13, var4);
            }
         });
         this.resolvedWeightedMap = var1.build();
         this.resolvedWeightedMapBtk = var2.build();
      }
   }

   class="kw">public boolean isEmpty() {
      class="kw">return this.weightedMap.size() == 0;
   }

   class="kw">public boolean hasInvalidBlocks() {
      this.resolve();
      class="kw">return this.hasInvalidBlocks;
   }

   class="kw">public int nextBlock(Random var1) {
      this.resolve();
      class="kw">return this.resolvedWeightedMap.get(var1);
   }

   @Nullable
   class="kw">public BlockPattern.BlockEntry nextBlockTypeKey(Random var1) {
      this.resolve();
      class="kw">return this.resolvedWeightedMapBtk.get(var1);
   }

   @Deprecated
   class="kw">public int firstBlock() {
      this.resolve();
      class="kw">return this.resolvedWeightedMap.size() > 0 ? this.resolvedWeightedMap.internalKeys()[0] : 0;
   }

   @Override
   class="kw">public String toString() {
      class="kw">return this.toString0;
   }

   class="kw">private String toString0() {
      if (this.weightedMap.size() == 1) {
         class="kw">return this.weightedMap.internalKeys()[0];
      }

      List var1 = new ObjectArrayList();
      this.weightedMap.forEachEntry((var1x, var2) -> var1.add(var2 + "%" + var1x));
      class="kw">return String.join(",", var1);
   }

   class="kw">public class="kw">static BlockPattern parse(@Nonnull String var0) {
      if (!var0.isEmpty() && !var0.equals("Empty")) {
         if (var0.toLowerCase(Locale.ROOT).contains("filler=")) {
            var0 = FILLER_TEMP_REMOVER_PATTERN.matcher(var0).replaceAll("$1;$2;$3");
         }

         var0 = var0.replace(";", ",");
         class="kw">return new BlockPattern(parseBlockPattern(var0.split(",", 0)));
      } else {
         class="kw">return EMPTY;
      }
   }

   @Nonnull
   class="kw">private class="kw">static IWeightedMap<String> parseBlockPattern(@Nonnull String... var0) {
      WeightedMap.Builder var1 = WeightedMap.builder(ArrayUtil.EMPTY_STRING_ARRAY);

      for (String var5 : var0) {
         if (!var5.isEmpty()) {
            double var6 = 100.0;
            String[] var8 = var5.split("%", 0);
            if (var8.length > 1) {
               try {
                  var6 = Double.parseDouble(var8[0]);
               } catch (NumberFormatException var10) {
                  throw new IllegalArgumentException("Invalid Chance Value: " + var8[0], var10);
               }

               var5 = var8[1];
            }

            var1.put(var5, var6);
         }
      }

      class="kw">return var1.build();
   }

   class="kw">public class="kw">static int parseBlock(@Nonnull String var0) {
      int var1;
      try {
         var1 = Integer.parseInt(var0);
         if (BlockType.getAssetMap().getAsset(var1) == null) {
            throw new IllegalArgumentException("Block with id '" + var0 + "' doesn't exist!");
         }
      } catch (NumberFormatException var4) {
         var0 = var0.replace(";", ",");
         int var3 = var0.indexOf("|");
         if (var3 != -1) {
            var0 = var0.substring(0, var3);
         }

         var1 = BlockType.getAssetMap().getIndex(var0);
         if (var1 == Integer.MIN_VALUE) {
            LOGGER.at(Level.WARNING).log("Invalid block name '%s' - using empty block", var0);
            class="kw">return 0;
         }
      }

      class="kw">return var1;
   }

   class="kw">public class="kw">static boolean canParseBlock(@Nonnull String var0) {
      try {
         int var6 = Integer.parseInt(var0);
         if (BlockType.getAssetMap().getAsset(var6) == null) {
            throw new IllegalArgumentException("Block with id '" + var0 + "' doesn't exist!");
         }
      } catch (NumberFormatException var4) {
         var0 = var0.replace(";", ",");
         int var3 = var0.indexOf("|");
         if (var3 != -1) {
            var0 = var0.substring(0, var3);
         }

         int var1 = BlockType.getAssetMap().getIndex(var0);
         if (var1 == Integer.MIN_VALUE) {
            LOGGER.at(Level.WARNING).log("Invalid block name '%s' - using empty block", var0);
            class="kw">return false;
         }
      }

      class="kw">return true;
   }

   @Nullable
   class="kw">public class="kw">static BlockPattern.BlockEntry tryParseBlockTypeKey(String var0) {
      try {
         var0 = var0.replace(";", ",");
         class="kw">return BlockPattern.BlockEntry.decode(var0);
      } catch (Exception var2) {
         class="kw">return null;
      }
   }

   class="kw">public record BlockEntry(String blockTypeKey, int rotation, int filler) {
      @Deprecated(forRemoval = true)
      class="kw">public class="kw">static class="kw">final Codec<BlockPattern.BlockEntry> CODEC = new FunctionCodec<>(
         Codec.STRING, BlockPattern.BlockEntry::decode, BlockPattern.BlockEntry::encode
      );

      class="kw">public BlockEntry {
      }

      @Deprecated(forRemoval = true)
      class="kw">private String encode() {
         if (this.filler == 0 && this.rotation == 0) {
            class="kw">return this.blockTypeKey;
         }

         StringBuilder var1 = new StringBuilder(this.blockTypeKey);
         RotationTuple var2 = RotationTuple.get(this.rotation);
         if (var2.yaw() != Rotation.None) {
            var1.append("|Yaw=").append(var2.yaw().getDegrees());
         }

         if (var2.pitch() != Rotation.None) {
            var1.append("|Pitch=").append(var2.pitch().getDegrees());
         }

         if (var2.roll() != Rotation.None) {
            var1.append("|Roll=").append(var2.roll().getDegrees());
         }

         if (this.filler != 0) {
            int var3 = FillerBlockUtil.unpackX(this.filler);
            int var4 = FillerBlockUtil.unpackY(this.filler);
            int var5 = FillerBlockUtil.unpackZ(this.filler);
            var1.append("|Filler=").append(var3).append(",").append(var4).append(",").append(var5);
         }

         class="kw">return var1.toString();
      }

      @Deprecated(forRemoval = true)
      class="kw">public class="kw">static BlockPattern.BlockEntry decode(String var0) {
         int var1 = 0;
         if (var0.contains("|Filler=")) {
            int var2 = var0.indexOf("|Filler=") + "|Filler=".length();
            int var3 = var0.indexOf(",", var2);
            if (var3 == -1) {
               throw new IllegalArgumentException("Invalid filler metadata! Missing comma");
            }

            int var4 = var0.indexOf(",", var3 + 1);
            if (var4 == -1) {
               throw new IllegalArgumentException("Invalid filler metadata! Missing second comma");
            }

            int var5 = var0.indexOf("|", var2);
            if (var5 == -1) {
               var5 = var0.length();
            }

            int var6 = Integer.parseInt(var0, var2, var3, 10);
            int var7 = Integer.parseInt(var0, var3 + 1, var4, 10);
            int var8 = Integer.parseInt(var0, var4 + 1, var5, 10);
            var1 = FillerBlockUtil.pack(var6, var7, var8);
         }

         Rotation var9 = Rotation.None;
         Rotation var10 = Rotation.None;
         Rotation var11 = Rotation.None;
         if (var0.contains("|Yaw=")) {
            int var12 = var0.indexOf("|Yaw=") + "|Yaw=".length();
            int var16 = var0.indexOf(124, var12);
            if (var16 == -1) {
               var16 = var0.length();
            }

            var9 = Rotation.ofDegrees(Integer.parseInt(var0, var12, var16, 10));
         }

         if (var0.contains("|Pitch=")) {
            int var13 = var0.indexOf("|Pitch=") + "|Pitch=".length();
            int var17 = var0.indexOf(124, var13);
            if (var17 == -1) {
               var17 = var0.length();
            }

            var10 = Rotation.ofDegrees(Integer.parseInt(var0, var13, var17, 10));
         }

         if (var0.contains("|Roll=")) {
            int var14 = var0.indexOf("|Roll=") + "|Roll=".length();
            int var18 = var0.indexOf("|", var14);
            if (var18 == -1) {
               var18 = var0.length();
            }

            var11 = Rotation.ofDegrees(Integer.parseInt(var0, var14, var18, 10));
         }

         int var15 = var0.indexOf("|");
         if (var15 == -1) {
            var15 = var0.length();
         }

         String var19 = var0.substring(0, var15);
         class="kw">return new BlockPattern.BlockEntry(var19, RotationTuple.of(var9, var10, var11).index(), var1);
      }
   }
}