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

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.bounds.Bounds3d;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import java.util.ArrayDeque;
class="kw">import java.util.Deque;
class="kw">import java.util.HashMap;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector2d;
class="kw">import org.joml.Vector3d;

class="kw">public class StackedBoundedCache<T> {
   class="kw">private class="kw">static class="kw">final double SEGMENT_HEIGHT_FACTOR = 0.5;
   @Nonnull
   class="kw">private class="kw">final Bounds3d bounds;
   class="kw">private class="kw">final double segmentHeight;
   @Nonnull
   class="kw">private class="kw">final Map<Vector2d, StackedBoundedCache.Column<T>> columns;
   class="kw">private class="kw">final int cacheCapacity;
   @Nonnull
   class="kw">private class="kw">final Deque<Vector2d> columnHistory;
   @Nonnull
   class="kw">private class="kw">final Vector2d rColumnPosition;

   class="kw">public StackedBoundedCache(@Nonnull Bounds3d var1, int var2) {
      assert var2 > 0;
      this.bounds = new Bounds3d(var1);
      this.segmentHeight = var1.getSize().y * 0.5;
      this.columns = new HashMap<>();
      this.cacheCapacity = var2;
      this.columnHistory = new ArrayDeque<>(var2);
      this.rColumnPosition = new Vector2d();
   }

   class="kw">public void get(@Nonnull Vector3d var1, @Nonnull List<StackedBoundedCache.Segment<T>> var2) {
      this.rColumnPosition.set(var1.x, var1.z);
      StackedBoundedCache.Column var3 = this.columns.get(this.rColumnPosition);
      if (var3 == null) {
         if (this.columnHistory.size() >= this.cacheCapacity) {
            Vector2d var4 = this.columnHistory.removeFirst();
            this.columns.remove(var4);
         }

         var3 = new StackedBoundedCache.Column<>();
         Vector2d var9 = new Vector2d(this.rColumnPosition);
         this.columns.put(var9, var3);
         this.columnHistory.addLast(var9);
      }

      int var10 = this.toIndex(this.bounds.min.y + var1.y);
      int var5 = this.toIndex(Math.nextDown(this.bounds.max.y + var1.y));

      for (int var6 = var10; var6 <= var5; var6++) {
         StackedBoundedCache.Segment var7 = (StackedBoundedCache.Segment<T>)var3.segments.get(var6);
         if (var7 == null) {
            Bounds3d var8 = new Bounds3d();
            this.getSegmentBounds(this.rColumnPosition, var6, var8);
            var7 = new StackedBoundedCache.Segment<>(var8);
            var3.segments.put(var6, var7);
         }

         var2.add(var7);
      }
   }

   class="kw">private void getSegmentBounds(@Nonnull Vector2d var1, int var2, @Nonnull Bounds3d var3) {
      var3.min.x = var1.x + this.bounds.min.x;
      var3.min.z = var1.y + this.bounds.min.z;
      var3.max.x = var1.x + this.bounds.max.x;
      var3.max.z = var1.y + this.bounds.max.z;
      var3.min.y = var2 * this.segmentHeight;
      var3.max.y = var3.min.y + this.segmentHeight;
   }

   class="kw">private int toIndex(double var1) {
      class="kw">return (int)Math.floor(var1 / this.segmentHeight);
   }

   class="kw">public class="kw">static class Column<T> {
      Int2ObjectMap<StackedBoundedCache.Segment<T>> segments = new Int2ObjectOpenHashMap();

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

   class="kw">public class="kw">static class Segment<T> {
      class="kw">public class="kw">final Bounds3d bounds;
      @Nullable
      class="kw">public T data;

      class="kw">public Segment(@Nonnull Bounds3d var1) {
         this.bounds = var1;
         this.data = null;
      }
   }
}