class="kw">package com.hypixel.hytale.builtin.adventure.worldevents.util;

class="kw">import com.hypixel.hytale.assetstore.codec.ContainedAssetCodec;
class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
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.codecs.EnumCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.buildertool.config.BlockTypeListAsset;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
class="kw">import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import java.util.Objects;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class PlacementMask {
   class="kw">protected class="kw">static class="kw">final Codec<String> BLOCK_LIST_CODEC = new ContainedAssetCodec<>(BlockTypeListAsset.class, BlockTypeListAsset.CODEC);
   class="kw">protected class="kw">static class="kw">final Codec<String[]> BLOCK_LISTS_CODEC = new ArrayCodec<>(BLOCK_LIST_CODEC, String[]::new);
   class="kw">public class="kw">static class="kw">final BuilderCodec<PlacementMask> CODEC = BuilderCodec.builder(PlacementMask.class, PlacementMask::new)
      .documentation("A mask that determines which blocks and fluids a given piece of content can be placed on.")
      .<PlacementMask.PlacementType>append(new KeyedCodec<>("Type", PlacementMask.PlacementType.CODEC), (var0, var1) -> var0.type = var1, var0 -> var0.type)
      .documentation("The type of placement that this mask controls.")
      .addValidator(Validators.nonNull())
      .add()
      .<String[]>append(new KeyedCodec<>("Blocks", BLOCK_LISTS_CODEC), (var0, var1) -> var0.blockLists = var1, var0 -> var0.blockLists)
      .documentation(
         "List of BlockTypeList assets to add to the blocks mask. Can be removed to allow placement on any block. Can be empty to prevent placement on any block."
      )
      .add()
      .<String[]>append(new KeyedCodec<>("Fluids", BLOCK_LISTS_CODEC), (var0, var1) -> var0.fluidLists = var1, var0 -> var0.fluidLists)
      .documentation(
         "List of BlockTypeList assets to add to the fluids mask. Can be removed to allow placement on any fluid. Can be empty to prevent placement on any fluid."
      )
      .add()
      .build();
   class="kw">public class="kw">static class="kw">final PlacementMask DEFAULT_ANY = new PlacementMask();
   class="kw">public class="kw">static class="kw">final PlacementMask DEFAULT_NONE = new PlacementMask() {
      {
         this.blockLists = ArrayUtil.EMPTY_STRING_ARRAY;
         this.fluidLists = ArrayUtil.EMPTY_STRING_ARRAY;
      }
   };
   @Nonnull
   class="kw">protected PlacementMask.PlacementType type = PlacementMask.PlacementType.BlocksAndFluids;
   @Nullable
   class="kw">protected String[] blockLists;
   @Nullable
   class="kw">protected String[] fluidLists;
   class="kw">protected class="kw">volatile boolean compiled = false;
   class="kw">protected class="kw">final IntSet blocks = new IntOpenHashSet();
   class="kw">protected class="kw">final IntSet fluids = new IntOpenHashSet();

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

   class="kw">public boolean testBlock(int var1) {
      assert this.compiled : "Mask must be compiled before use!";

      class="kw">return class="kw">switch (this.type) {
         case BlocksAndFluids -> var1 == 0 || this.blockLists == null || this.blocks.contains(var1);
         case BlocksOnly -> this.blockLists == null || this.blocks.contains(var1);
         case FluidsOnly -> var1 == 0;
      };
   }

   class="kw">public boolean testFluid(int var1) {
      assert this.compiled : "Mask must be compiled before use!";

      class="kw">return class="kw">switch (this.type) {
         case BlocksAndFluids -> var1 == 0 || this.fluidLists == null || this.fluids.contains(var1);
         case BlocksOnly -> var1 == 0;
         case FluidsOnly -> var1 != 0 && (this.fluidLists == null || this.fluids.contains(var1));
      };
   }

   class="kw">public void compile() {
      if (!this.compiled) {
         class="kw">synchronized (this) {
            if (!this.compiled) {
               this.blocks.clear();
               this.fluids.clear();
               this.compiled = true;
               BlockTypeAssetMap var2 = BlockType.getAssetMap();
               IndexedLookupTableAssetMap var3 = Fluid.getAssetMap();
               DefaultAssetMap var4 = BlockTypeListAsset.getAssetMap();

               for (String var8 : Objects.requireNonNullElse(this.blockLists, ArrayUtil.EMPTY_STRING_ARRAY)) {
                  if (var8 != null) {
                     BlockTypeListAsset var9 = var4.getAsset(var8);
                     if (var9 != null) {
                        for (String var11 : var9.getBlockTypeKeys()) {
                           int var12 = var2.getIndex(var11);
                           if (var12 != 1) {
                              this.blocks.add(var12);
                           }
                        }
                     }
                  }
               }

               for (String var18 : Objects.requireNonNullElse(this.fluidLists, ArrayUtil.EMPTY_STRING_ARRAY)) {
                  if (var18 != null) {
                     BlockTypeListAsset var19 = var4.getAsset(var18);
                     if (var19 != null) {
                        for (String var21 : var19.getBlockTypeKeys()) {
                           int var22 = var3.getIndex(var21);
                           if (var22 != 1) {
                              this.fluids.add(var22);
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">public enum PlacementType {
      BlocksAndFluids,
      BlocksOnly,
      FluidsOnly;

      class="kw">public class="kw">static class="kw">final EnumCodec<PlacementMask.PlacementType> CODEC = new EnumCodec<>(PlacementMask.PlacementType.class);

      PlacementType() {
      }

      class="kw">static {
         CODEC.documentKey(BlocksAndFluids, "Placement is allowed on blocks and fluids.");
         CODEC.documentKey(BlocksOnly, "Placement is only allowed on blocks.");
         CODEC.documentKey(FluidsOnly, "Placement is only allowed on fluids.");
      }
   }
}