class="kw">package com.hypixel.hytale.builtin.hytalegenerator.props.deprecated.prefab;

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.BlockMask;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.EntityPlacementData;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.WeightedMap;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.bounds.Bounds3i;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.engine.entityfunnel.EntityFunnel;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.material.Material;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.material.MaterialCache;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.patterns.ConstantPattern;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.patterns.Pattern;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.props.Prop;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.props.deprecated.ScanResult;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.props.deprecated.directionality.Directionality;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.props.deprecated.directionality.RotatedPosition;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.props.deprecated.directionality.RotatedPositionsScanResult;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.props.deprecated.directionality.StaticDirectionality;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.rng.RngField;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.rng.SeedBox;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.scanners.DirectScanner;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.scanners.Scanner;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.voxelspace.ArrayVoxelSpace;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.voxelspace.VoxelSpace;
class="kw">import com.hypixel.hytale.common.util.ExceptionUtil;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.prefab.PrefabRotation;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.PrefabBufferCall;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.impl.IPrefabBuffer;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.buffer.impl.PrefabBuffer;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import java.util.Random;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class PrefabProp class="kw">extends Prop {
   @Nonnull
   class="kw">private class="kw">final WeightedMap<List<IPrefabBuffer>> prefabPool;
   @Nonnull
   class="kw">private class="kw">final Scanner scanner;
   @Nonnull
   class="kw">private class="kw">final MaterialCache materialCache;
   @Nonnull
   class="kw">private class="kw">final RngField rngField;
   @Nonnull
   class="kw">private class="kw">final BlockMask materialMask;
   @Nonnull
   class="kw">private class="kw">final Directionality directionality;
   @Nonnull
   class="kw">private class="kw">final Bounds3i readBounds_voxelGrid;
   @Nonnull
   class="kw">private class="kw">final Bounds3i writeBounds_voxelGrid;
   @Nonnull
   class="kw">private class="kw">final List<PrefabProp> childProps;
   @Nonnull
   class="kw">private class="kw">final List<RotatedPosition> childPositions;
   @Nonnull
   class="kw">private class="kw">final Function<String, List<IPrefabBuffer>> childPrefabLoader;
   class="kw">private class="kw">final Scanner moldingScanner;
   class="kw">private class="kw">final Pattern moldingPattern;
   class="kw">private class="kw">final MoldingDirection moldingDirection;
   class="kw">private class="kw">final boolean moldChildren;
   class="kw">private boolean loadEntities;
   @Nonnull
   class="kw">private class="kw">final MaterialCache.MaterialKey rMaterialKey = new MaterialCache.MaterialKey();

   class="kw">public PrefabProp(
      @Nonnull WeightedMap<List<IPrefabBuffer>> var1,
      @Nonnull Scanner var2,
      @Nonnull Directionality var3,
      @Nonnull MaterialCache var4,
      @Nonnull BlockMask var5,
      @Nonnull PrefabMoldingConfiguration var6,
      @Nullable Function<String, List<IPrefabBuffer>> var7,
      @Nonnull SeedBox var8,
      boolean var9
   ) {
      this.prefabPool = var1;
      this.scanner = var2;
      this.directionality = var3;
      this.materialCache = var4;
      this.rngField = new RngField(var8.createSupplier().get());
      this.materialMask = var5;
      this.loadEntities = var9;
      this.childProps = new ArrayList<>();
      this.childPositions = new ArrayList<>();
      this.childPrefabLoader = var7 == null ? var0 -> null : var7;
      this.moldingScanner = var6.moldingScanner;
      this.moldingPattern = var6.moldingPattern;
      this.moldingDirection = var6.moldingDirection;
      this.moldChildren = var6.moldChildren;
      this.readBounds_voxelGrid = var3.getBoundsWith_voxelGrid(var2);
      this.writeBounds_voxelGrid = new Bounds3i();

      for (List var11 : var1.elements()) {
         if (var11.isEmpty()) {
            class="kw">return;
         }

         for (IPrefabBuffer var13 : var11) {
            if (var13 == null) {
               throw new IllegalArgumentException("prefab pool contains list with null element");
            }

            this.writeBounds_voxelGrid.encompass(this.getWriteBounds_voxelGrid(var13));
            PrefabBuffer.ChildPrefab[] var14 = var13.getChildPrefabs();
            int var15 = 0;

            for (PrefabBuffer.ChildPrefab var19 : var14) {
               RotatedPosition var20 = new RotatedPosition(var19.getX(), var19.getY(), var19.getZ(), var19.getRotation());
               String var21 = var19.getPath().replace('.', '/');
               var21 = var21.replace("*", "");
               List var22 = this.childPrefabLoader.apply(var21);
               WeightedMap var23 = new WeightedMap<>();
               var23.add(var22, 1.0);
               StaticDirectionality var24 = new StaticDirectionality(var19.getRotation(), ConstantPattern.INSTANCE_TRUE);
               PrefabProp var25 = new PrefabProp(
                  var23,
                  new DirectScanner(),
                  var24,
                  var4,
                  var5,
                  this.moldChildren ? var6 : PrefabMoldingConfiguration.none(),
                  var7,
                  var8.child(String.valueOf(var15++)),
                  var9
               );
               this.childProps.add(var25);
               this.childPositions.add(var20);
            }

            for (int var26 = 0; var26 < this.childPositions.size(); var26++) {
               PrefabProp var27 = this.childProps.get(var26);
               Vector3i var28 = this.childPositions.get(var26).toVector3i();
               Bounds3i var29 = var27.getWriteBounds_voxelGrid().clone();
               var29.offset(var28);
               this.writeBounds_voxelGrid.encompass(var29);
            }
         }
      }

      this.writeBounds_voxelGrid.stack(var2.getBounds_voxelGrid());
   }

   @Nonnull
   class="kw">private Bounds3i getWriteBounds_voxelGrid(@Nonnull IPrefabBuffer var1) {
      Bounds3i var2 = new Bounds3i();

      for (PrefabRotation var4 : this.directionality.getPossibleRotations()) {
         Vector3i var5 = PrefabPropUtil.getMax(var1, var4);
         var5.add(1, 1, 1);
         Vector3i var6 = PrefabPropUtil.getMin(var1, var4);
         var2.encompass(var6);
         var2.encompass(var5);
      }

      class="kw">return var2;
   }

   @Override
   class="kw">public boolean generate(@Nonnull Prop.Context var1) {
      ScanResult var2 = this.scan_deprecated(var1.position, var1.materialReadSpace);
      this.place_deprecated(var1, var2);
      class="kw">return !var2.isNegative();
   }

   @Nonnull
   class="kw">public ScanResult scan_deprecated(@Nonnull Vector3i var1, @Nonnull VoxelSpace<Material> var2) {
      List var3 = new ArrayList<>();
      Scanner.Context var4 = new Scanner.Context(var1, this.directionality.getGeneralPattern(), var2, var3);
      this.scanner.scan(var4);
      Vector3i var5 = new Vector3i();
      Pattern.Context var6 = new Pattern.Context(var5, var2);
      RotatedPositionsScanResult var7 = new RotatedPositionsScanResult(new ArrayList<>());

      for (Vector3i var9 : var3) {
         var5.set(var9);
         PrefabRotation var10 = this.directionality.getRotationAt(var6);
         if (var10 != null) {
            var7.positions.add(new RotatedPosition(var9.x, var9.y, var9.z, var10));
         }
      }

      class="kw">return var7;
   }

   class="kw">public void place_deprecated(@Nonnull Prop.Context var1, @Nonnull ScanResult var2) {
      if (this.prefabPool.size() != 0) {
         List var3 = RotatedPositionsScanResult.cast(var2).positions;
         if (var3 != null) {
            Bounds3i var4 = this.writeBounds_voxelGrid.clone().offset(var1.position);
            if (var4.intersects(var4)) {
               Bounds3i var5 = var1.materialWriteSpace.getBounds();

               for (RotatedPosition var7 : var3) {
                  this.place(var7, var1.materialWriteSpace, var1.entityWriteBuffer);
               }
            }
         }
      }
   }

   @Nullable
   class="kw">private IPrefabBuffer pickPrefab(@Nonnull Random var1) {
      List var2 = this.prefabPool.pick(var1);
      if (var2.isEmpty()) {
         class="kw">return null;
      }

      int var3 = var1.nextInt(var2.size());
      class="kw">return var2.get(var3);
   }

   class="kw">public void place(@Nonnull RotatedPosition var1, @Nonnull VoxelSpace<Material> var2, @Nonnull EntityFunnel var3) {
      if (this.prefabPool.size() != 0) {
         Random var4 = new Random(this.rngField.get(var1.x, var1.y, var1.z));
         PrefabBufferCall var5 = new PrefabBufferCall(var4, var1.rotation);
         IPrefabBuffer var6 = this.pickPrefab(var4);
         if (var6 != null) {
            VoxelSpace var7 = null;
            if (this.moldingDirection != MoldingDirection.NONE) {
               int var8 = var6.getMinX(var1.rotation);
               int var9 = var6.getMinZ(var1.rotation);
               int var10 = var6.getMaxX(var1.rotation);
               int var11 = var6.getMaxZ(var1.rotation);
               Bounds3i var12 = new Bounds3i(new Vector3i(var8 + var1.x, 0, var9 + var1.z), new Vector3i(var10 + var1.x, 1, var11 + var1.z));
               var7 = new ArrayVoxelSpace<>(var12);
               if (this.moldingDirection == MoldingDirection.DOWN || this.moldingDirection == MoldingDirection.UP) {
                  Vector3i var13 = new Vector3i(0, var1.y, 0);
                  Scanner.Context var14 = new Scanner.Context(var13, this.moldingPattern, var2, new ArrayList<>());

                  for (var13.x = var12.min.x; var13.x < var12.max.x; var13.x++) {
                     for (var13.z = var12.min.z; var13.z < var12.max.z; var13.z++) {
                        var14.validPositions_out.clear();
                        this.moldingScanner.scan(var14);
                        Integer var15 = var14.validPositions_out.isEmpty() ? null : var14.validPositions_out.getFirst().y - var1.y;
                        if (var15 != null && this.moldingDirection == MoldingDirection.UP) {
                           var15 = var15 - 1;
                        }

                        var7.set(var15, var13.x, 0, var13.z);
                     }
                  }
               }
            }

            try {
               Vector3i var17 = var1.toVector3i();
               VoxelSpace var22 = var7;
               int var24 = Objects.hash(var1.x, var1.y, var1.z, var6.hashCode());
               var6.forEach(IPrefabBuffer.iterateAllColumns(), (var4x, var5x, var6x, var7x, var8x, var9x, var10x, var11x, var12x, var13x, var14x) -> {
                  int var15 = var1.x + var4x;
                  int var16 = var1.y + var5x;
                  int var17 = var1.z + var6x;
                  if (var2.getBounds().contains(var15, var16, var17)) {
                     this.rMaterialKey.getSolidKey().set(var7x, var9x, var10x, var11x, var8x != null ? var8x.clone() : null);
                     this.rMaterialKey.getFluidKey().set(var13x, (byte)var14x);
                     Material var18 = this.materialCache.getMaterial(this.rMaterialKey);
                     int var19 = var18.hashMaterialIds();
                     if (this.materialMask.canPlace(var19)) {
                        if (this.moldingDirection == MoldingDirection.DOWN || this.moldingDirection == MoldingDirection.UP) {
                           Integer var20 = null;
                           if (var22.getBounds().contains(var15, 0, var17)) {
                              var20 = var22.get(var15, 0, var17);
                           }

                           if (var20 == null) {
                              class="kw">return;
                           }

                           var16 += var20;
                        }

                        Material var22 = var2.get(var15, var16, var17);
                        int var21 = var22.hashMaterialIds();
                        if (this.materialMask.canReplace(var19, var21)) {
                           if (var11x == 0) {
                              var2.set(var18, var15, var16, var17);
                           }
                        }
                     }
                  }
               }, (var5x, var6x, var7x, var8x) -> {
                  if (this.loadEntities) {
                     if (var7x != null) {
                        for (int var9 = 0; var9 < var7x.length; var9++) {
                           TransformComponent var10 = var7x[var9].getComponent(TransformComponent.getComponentType());
                           if (var10 != null) {
                              Vector3d var11 = new Vector3d(var10.getPosition());
                              var8x.rotation.rotate(var11);
                              Vector3d var12 = var11.add(var17.x, var17.y, var17.z);
                              if (var3.getBounds().contains(var12)) {
                                 Holder var13 = var7x[var9].clone();
                                 var10 = var13.getComponent(TransformComponent.getComponentType());
                                 if (var10 != null) {
                                    var11 = var10.getPosition();
                                    var11.x = var12.x;
                                    var11.y = var12.y;
                                    var11.z = var12.z;
                                    if (!var2.getBounds().contains((int)Math.floor(var11.x), (int)Math.floor(var11.y), (int)Math.floor(var11.z))) {
                                       class="kw">return;
                                    }

                                    EntityPlacementData var14 = new EntityPlacementData(new Vector3i(), PrefabRotation.ROTATION_0, var13, var24);
                                    var3.addEntity(var14);
                                 }
                              }
                           }
                        }
                     }
                  }
               }, (var0, var1x, var2x, var3x, var4x, var5x, var6x, var7x, var8x, var9x) -> {}, var5);
            } catch (Exception var16) {
               String var19 = "Couldn't place prefab prop.";
               var19 = var19 + "\n";
               var19 = var19 + ExceptionUtil.toStringWithStack(var16);
               ((HytaleLogger.Api)HytaleLogger.getLogger().atWarning()).log("%s", var19);
            }

            for (int var18 = 0; var18 < this.childProps.size(); var18++) {
               PrefabProp var23 = this.childProps.get(var18);
               RotatedPosition var25 = this.childPositions.get(var18).getRelativeTo(var1);
               Vector3i var26 = new Vector3i(var25.x, var25.y, var25.z);
               var1.rotation.rotate(var26);
               if (var7 != null && var7.getBounds().contains(var25.x, 0, var25.z)) {
                  Integer var27 = var7.get(var25.x, 0, var25.z);
                  if (var27 == null) {
                     class="kw">continue;
                  }

                  int var28 = var25.y + var27;
                  var25 = new RotatedPosition(var25.x, var28, var25.z, var25.rotation);
               }

               var23.place(var25, var2, var3);
            }
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public Bounds3i getReadBounds_voxelGrid() {
      class="kw">return this.readBounds_voxelGrid;
   }

   @Nonnull
   @Override
   class="kw">public Bounds3i getWriteBounds_voxelGrid() {
      class="kw">return this.writeBounds_voxelGrid;
   }
}