class="kw">package com.hypixel.hytale.builtin.hytalegenerator.density;

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.GridCache;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.ReusableList;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.StackedBoundedCache;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.VectorUtil;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.bounds.Bounds3d;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.bounds.Bounds3i;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.graph.GraphGenerator;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.graph.GraphSpace;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.math.Calculator;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
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 GraphDensity class="kw">extends Density {
   class="kw">private class="kw">static class="kw">final int GRAPH_PROBE_ID = 0;
   class="kw">private class="kw">static class="kw">final int DENSITY_PROBE_ID = 1;
   @Nonnull
   class="kw">private class="kw">final GraphGenerator graphGenerator;
   @Nonnull
   class="kw">private class="kw">final StackedBoundedCache<GraphDensity.QueryResult> queryCache;
   @Nonnull
   class="kw">private class="kw">final GridCache<GraphSpace.ReadOnly> grid;
   class="kw">private class="kw">final double backgroundDensity;
   class="kw">private class="kw">final double transitionSlope;
   class="kw">private class="kw">final double transitionOffset;
   class="kw">private class="kw">final double transitionSmooth;
   @Nonnull
   class="kw">private class="kw">final List<GraphDensity.DensityContent> indexedContent;
   class="kw">private class="kw">final boolean isEmpty;
   @Nonnull
   class="kw">private class="kw">final Vector3i rCellIndex;
   @Nonnull
   class="kw">private class="kw">final Vector3d rAnchor;
   @Nonnull
   class="kw">private class="kw">final Vector3d rSegmentBoundsMaxInclusive;
   @Nonnull
   class="kw">private class="kw">final Bounds3d rIntersectingCellBounds;
   @Nonnull
   class="kw">private class="kw">final Bounds3i rCellIndexBounds;
   @Nonnull
   class="kw">private class="kw">final ReusableList<GraphDensity.DensityDistanceEntry> rDensityDistanceEntries;
   @Nonnull
   class="kw">private class="kw">final Density.Context rNodeContext;
   @Nonnull
   class="kw">private class="kw">final List<StackedBoundedCache.Segment<GraphDensity.QueryResult>> rQueryResults;

   class="kw">public GraphDensity(
      @Nonnull GraphGenerator var1,
      @Nonnull GridCache<GraphSpace.ReadOnly> var2,
      double var3,
      double var5,
      double var7,
      double var9,
      int var11,
      @Nonnull List<GraphDensity.DensityContent> var12
   ) {
      assert var9 >= 0.0;
      assert var11 >= 0;
      this.graphGenerator = var1;
      this.grid = var2;
      this.backgroundDensity = var3;
      this.transitionSlope = var5;
      this.transitionOffset = var7;
      this.transitionSmooth = var9;
      this.indexedContent = new ArrayList<>(var12);
      double var13 = 0.0;

      for (GraphDensity.DensityContent var16 : var12) {
         var13 = Math.max(var16.radius, var13);
      }

      double var18 = 30.0;
      Bounds3d var17 = new Bounds3d(
         new Vector3d(Math.nextUp(-var13), Math.min(-30.0, -var13), Math.nextUp(-var13)), new Vector3d(var13, Math.max(30.0, var13), var13)
      );
      this.queryCache = new StackedBoundedCache<>(var17, var11);
      this.isEmpty = var13 == 0.0;
      this.rCellIndex = new Vector3i();
      this.rAnchor = new Vector3d();
      this.rIntersectingCellBounds = new Bounds3d();
      this.rDensityDistanceEntries = new ReusableList<>();
      this.rNodeContext = new Density.Context();
      this.rQueryResults = new ArrayList<>();
      this.rSegmentBoundsMaxInclusive = new Vector3d();
      this.rCellIndexBounds = new Bounds3i();
   }

   @Override
   class="kw">public double process(@Nonnull Density.Context var1) {
      if (this.isEmpty) {
         class="kw">return 0.0;
      }

      this.clearDistanceEntries();
      this.rQueryResults.clear();
      this.queryCache.get(var1.position, this.rQueryResults);

      for (int var2 = 0; var2 < this.rQueryResults.size(); var2++) {
         StackedBoundedCache.Segment var3 = this.rQueryResults.get(var2);
         if (var3.data == null) {
            var3.data = new GraphDensity.QueryResult();
            this.rSegmentBoundsMaxInclusive.set(var3.bounds.max);
            VectorUtil.nextDown(this.rSegmentBoundsMaxInclusive);
            this.grid.toCellIndex(var3.bounds.min, this.rCellIndexBounds.min);
            this.grid.toCellIndex(this.rSegmentBoundsMaxInclusive, this.rCellIndexBounds.max);
            this.rCellIndexBounds.max.add(1, 1, 1);

            for (int var4 = this.rCellIndexBounds.min.x; var4 < this.rCellIndexBounds.max.x; var4++) {
               for (int var5 = this.rCellIndexBounds.min.y; var5 < this.rCellIndexBounds.max.y; var5++) {
                  for (int var6 = this.rCellIndexBounds.min.z; var6 < this.rCellIndexBounds.max.z; var6++) {
                     this.rCellIndex.set(var4, var5, var6);
                     this.grid.toCellBounds(this.rCellIndex, this.rIntersectingCellBounds);
                     this.rIntersectingCellBounds.intersect(var3.bounds);
                     VectorUtil.nextDown(this.rIntersectingCellBounds.max);
                     GraphSpace.ReadOnly var7 = this.grid.getCell(this.rCellIndex, this.graphGenerator);
                     assert var7 != null;
                     if (var7 != null) {
                        var7.getNodes(this.rIntersectingCellBounds, var3.data.nodes);
                     }
                  }
               }
            }
         }

         for (int var17 = 0; var17 < var3.data.nodes.size(); var17++) {
            GraphSpace.Node var19 = var3.data.nodes.get(var17);
            int var20 = var19.content().index;
            if (var20 != -1) {
               GraphDensity.DensityContent var22 = this.indexedContent.get(var20);
               if (var22 != null) {
                  double var8 = var19.position().distanceSquared(var1.position);
                  if (!(var8 > var22.rangeSquared)) {
                     double var10 = Math.sqrt(var8);
                     double var12 = var22.radius - var10;
                     var12 /= var22.radius;
                     var12 = factorFunction(var12, this.transitionSlope, this.transitionOffset, this.transitionSmooth);
                     if (!(var12 <= 0.0)) {
                        if (this.rDensityDistanceEntries.isAtHardCapacity()) {
                           this.rDensityDistanceEntries.expandAndSet(new GraphDensity.DensityDistanceEntry(var19, var12, var22));
                        } else {
                           GraphDensity.DensityDistanceEntry var14 = this.rDensityDistanceEntries.expandAndGet();
                           assert var14 != null;
                           var14.node = var19;
                           var14.factor = var12;
                           var14.densityContent = var22;
                        }
                     }
                  }
               }
            }
         }
      }

      if (this.rDensityDistanceEntries.getSoftSize() == 0) {
         this.rQueryResults.clear();
         class="kw">return this.backgroundDensity;
      }

      double var15 = 0.0;
      double var18 = 0.0;

      for (int var21 = 0; var21 < this.rDensityDistanceEntries.getSoftSize(); var21++) {
         GraphDensity.DensityDistanceEntry var23 = this.rDensityDistanceEntries.get(var21);
         assert var23 != null && var23.densityContent != null && var23.node != null;
         this.rNodeContext.assign(var1);
         this.rNodeContext.graphNode = var23.node;
         this.rAnchor.set(var23.node.position());
         this.rNodeContext.densityAnchor = this.rAnchor;
         double var24 = var23.densityContent.density.process(this.rNodeContext);
         var15 += var24 * var23.factor;
         var18 += var23.factor;
      }

      var15 /= var18;
      this.rQueryResults.clear();
      this.clearDistanceEntries();
      this.rNodeContext.clearReferences();
      class="kw">return var15;

      throw new AssertionError();
   }

   class="kw">private void clearDistanceEntries() {
      for (int var1 = 0; var1 < this.rDensityDistanceEntries.getSoftSize(); var1++) {
         GraphDensity.DensityDistanceEntry var2 = this.rDensityDistanceEntries.get(var1);
         if (var2 != null) {
            var2.clear();
         }
      }

      this.rDensityDistanceEntries.clear();
   }

   class="kw">public class="kw">static double factorFunction(double var0, double var2, double var4, double var6) {
      double var8 = 0.5 * (1.0 - 1.0 / var2);
      var0 -= var8 + var4;
      class="kw">return Math.max(Calculator.smoothMin(var6, var0 * var2, 1.0), 0.0);
   }

   class="kw">public class="kw">static class DensityContent {
      class="kw">public class="kw">static class="kw">final GraphDensity.DensityContent EMPTY = new GraphDensity.DensityContent(new ConstantValueDensity(0.0), 0.0);
      @Nonnull
      class="kw">public class="kw">final Density density;
      class="kw">public class="kw">final double radius;
      class="kw">public class="kw">final double rangeSquared;

      class="kw">public DensityContent(@Nonnull Density var1, double var2) {
         assert var2 >= 0.0;
         this.density = var1;
         this.radius = var2;
         this.rangeSquared = var2 * var2;
      }
   }

   class="kw">private class="kw">static class DensityDistanceEntry {
      @Nullable
      GraphSpace.Node node;
      double factor;
      @Nullable
      GraphDensity.DensityContent densityContent;

      DensityDistanceEntry(@Nonnull GraphSpace.Node var1, double var2, @Nonnull GraphDensity.DensityContent var4) {
         this.node = var1;
         this.factor = var2;
         this.densityContent = var4;
      }

      void clear() {
         this.node = null;
         this.factor = 0.0;
         this.densityContent = null;
      }
   }

   class="kw">private class="kw">static class QueryResult {
      @Nonnull
      List<GraphSpace.Node> nodes = new ArrayList<>();

      QueryResult() {
      }
   }
}