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

class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabRotation;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabWeights;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.PrefabBufferCall;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">interface IPrefabBuffer {
   IPrefabBuffer.ColumnPredicate<?> ALL_COLUMNS = (var0, var1, var2, var3) -> true;

   int getAnchorX();

   int getAnchorY();

   int getAnchorZ();

   int getMinX(@Nonnull PrefabRotation var1);

   int getMinY();

   int getMinZ(@Nonnull PrefabRotation var1);

   int getMaxX(@Nonnull PrefabRotation var1);

   int getMaxY();

   int getMaxZ(@Nonnull PrefabRotation var1);

   class="kw">default int getMinX() {
      class="kw">return this.getMinX(PrefabRotation.ROTATION_0);
   }

   class="kw">default int getMinZ() {
      class="kw">return this.getMinZ(PrefabRotation.ROTATION_0);
   }

   class="kw">default int getMaxX() {
      class="kw">return this.getMaxX(PrefabRotation.ROTATION_0);
   }

   class="kw">default int getMaxZ() {
      class="kw">return this.getMaxZ(PrefabRotation.ROTATION_0);
   }

   int getMinYAt(@Nonnull PrefabRotation var1, int var2, int var3);

   int getMaxYAt(@Nonnull PrefabRotation var1, int var2, int var3);

   int getColumnCount();

   @Nonnull
   PrefabBuffer.ChildPrefab[] getChildPrefabs();

   class="kw">default int getMaximumExtend() {
      int var1 = 0;

      for (PrefabRotation var5 : PrefabRotation.VALUES) {
         int var6 = this.getMaxX(var5) - this.getMinX(var5);
         if (var6 > var1) {
            var1 = var6;
         }

         int var7 = this.getMaxZ(var5) - this.getMinZ(var5);
         if (var7 > var1) {
            var1 = var7;
         }
      }

      class="kw">return var1;
   }

   <T class="kw">extends PrefabBufferCall> void forEach(
      @Nonnull IPrefabBuffer.ColumnPredicate<T> var1,
      @Nonnull IPrefabBuffer.BlockConsumer<T> var2,
      @Nullable IPrefabBuffer.EntityConsumer<T> var3,
      @Nullable IPrefabBuffer.ChildConsumer<T> var4,
      @Nonnull T var5
   );

   <T> void forEachEntity(@Nonnull IPrefabBuffer.EntityConsumer<T> var1, @Nullable T var2);

   <T> void forEachRaw(
      @Nonnull IPrefabBuffer.ColumnPredicate<T> var1,
      @Nonnull IPrefabBuffer.RawBlockConsumer<T> var2,
      @Nonnull IPrefabBuffer.FluidConsumer<T> var3,
      @Nullable IPrefabBuffer.EntityConsumer<T> var4,
      @Nullable T var5
   );

   <T> boolean forEachRaw(
      @Nonnull IPrefabBuffer.ColumnPredicate<T> var1,
      @Nonnull IPrefabBuffer.RawBlockPredicate<T> var2,
      @Nonnull IPrefabBuffer.FluidPredicate<T> var3,
      @Nullable IPrefabBuffer.EntityPredicate<T> var4,
      @Nullable T var5
   );

   class="kw">default <T class="kw">extends PrefabBufferCall> boolean compare(@Nonnull IPrefabBuffer.BlockComparingPredicate<T> var1, @Nonnull T var2) {
      class="kw">return this.forEachRaw(
         iterateAllColumns(),
         (var1x, var2x, var3, var4, var5, var6, var7, var8, var9, var10) -> var1.test(var1x, var2x, var3, var4, var8, var6, (T)var10),
         (var0, var1x, var2x, var3, var4, var5) -> true,
         (var0, var1x, var2x, var3) -> true,
         var2
      );
   }

   class="kw">default <T class="kw">extends PrefabBufferCall> boolean compare(
      @Nonnull IPrefabBuffer.BlockComparingPrefabPredicate<T> var1, @Nonnull T var2, @Nonnull IPrefabBuffer var3
   ) {
      throw new UnsupportedOperationException("Not implemented! Please implement some inefficient class="kw">default here!");
   }

   int getBlockId(int var1, int var2, int var3);

   int getFiller(int var1, int var2, int var3);

   int getRotationIndex(int var1, int var2, int var3);

   @Nonnull
   class="kw">static <T> IPrefabBuffer.ColumnPredicate<T> iterateAllColumns() {
      class="kw">return (IPrefabBuffer.ColumnPredicate<T>)ALL_COLUMNS;
   }

   @FunctionalInterface
   class="kw">interface BlockComparingPredicate<T> {
      boolean test(int var1, int var2, int var3, int var4, int var5, Holder<ChunkStore> var6, T var7);
   }

   @FunctionalInterface
   class="kw">interface BlockComparingPrefabPredicate<T> {
      boolean test(
         int var1,
         int var2,
         int var3,
         int var4,
         Holder<ChunkStore> var5,
         float var6,
         int var7,
         int var8,
         int var9,
         Holder<ChunkStore> var10,
         float var11,
         int var12,
         int var13,
         T var14
      );
   }

   @FunctionalInterface
   class="kw">interface BlockConsumer<T> {
      void accept(int var1, int var2, int var3, int var4, @Nullable Holder<ChunkStore> var5, int var6, int var7, int var8, T var9, int var10, int var11);
   }

   @FunctionalInterface
   class="kw">interface ChildConsumer<T> {
      void accept(int var1, int var2, int var3, String var4, boolean var5, boolean var6, boolean var7, PrefabWeights var8, PrefabRotation var9, T var10);
   }

   @FunctionalInterface
   class="kw">interface ColumnPredicate<T> {
      boolean test(int var1, int var2, int var3, T var4);
   }

   @FunctionalInterface
   class="kw">interface EntityConsumer<T> {
      void accept(int var1, int var2, @Nullable Holder<EntityStore>[] var3, T var4);
   }

   @FunctionalInterface
   class="kw">interface EntityPredicate<T> {
      boolean test(int var1, int var2, @Nonnull Holder<EntityStore>[] var3, T var4);
   }

   @FunctionalInterface
   class="kw">interface FluidConsumer<T> {
      void accept(int var1, int var2, int var3, int var4, byte var5, T var6);
   }

   @FunctionalInterface
   class="kw">interface FluidPredicate<T> {
      boolean test(int var1, int var2, int var3, int var4, byte var5, T var6);
   }

   @FunctionalInterface
   class="kw">interface RawBlockConsumer<T> {
      void accept(int var1, int var2, int var3, int var4, int var5, float var6, Holder<ChunkStore> var7, int var8, int var9, int var10, T var11);
   }

   @FunctionalInterface
   class="kw">interface RawBlockPredicate<T> {
      boolean test(int var1, int var2, int var3, int var4, float var5, Holder<ChunkStore> var6, int var7, int var8, int var9, T var10);
   }
}