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

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.GridUtils;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.bounds.Bounds3i;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.engine.bufferbundle.buffers.Buffer;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.engine.bufferbundle.buffers.type.BufferType;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.engine.performanceinstruments.MemInstrument;
class="kw">import java.util.ArrayDeque;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Arrays;
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 java.util.Map.Entry;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3i;

class="kw">public class BufferBundle class="kw">implements MemInstrument {
   @Nonnull
   class="kw">private class="kw">final Map<BufferType, BufferBundle.Grid> grids = new HashMap<>();

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

   @Nonnull
   class="kw">public BufferBundle.Grid createGrid(@Nonnull BufferType var1, int var2) {
      assert var2 >= 0;
      assert !this.grids.containsKey(var1);
      assert !this.existingGridHasBufferTypeIndex(var1.index);
      BufferBundle.Grid var3 = new BufferBundle.Grid(var1, var2);
      this.grids.put(var1, var3);
      class="kw">return var3;
   }

   @Nonnull
   class="kw">public BufferBundle.Access createBufferAccess(@Nonnull BufferType var1, @Nonnull Bounds3i var2) {
      assert var2.isCorrect();
      class="kw">return this.getGrid(var1).openAccess(var2);
   }

   class="kw">public void closeALlAccesses() {
      for (BufferBundle.Grid var2 : this.grids.values()) {
         var2.closeAllAccesses();
      }
   }

   @Nonnull
   class="kw">public BufferBundle.Grid getGrid(@Nonnull BufferType var1) {
      BufferBundle.Grid var2 = this.grids.get(var1);
      assert var2 != null;
      class="kw">return var2;
   }

   @Nonnull
   @Override
   class="kw">public MemInstrument.Report getMemoryUsage() {
      long var1 = 16L;

      for (Entry var4 : this.grids.entrySet()) {
         var1 += var4.getValue().getMemoryUsage().size_bytes();
      }

      class="kw">return new MemInstrument.Report(var1);
   }

   class="kw">private boolean existingGridHasBufferTypeIndex(int var1) {
      for (BufferBundle.Grid var3 : this.grids.values()) {
         if (var3.bufferType.index == var1) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   @Nonnull
   class="kw">public BufferBundle.MemoryReport createMemoryReport() {
      BufferBundle.MemoryReport var1 = new BufferBundle.MemoryReport();

      for (BufferBundle.Grid var3 : this.grids.values()) {
         MemInstrument.Report var4 = var3.getMemoryUsage();
         int var5 = var3.buffers.size();
         var1.gridEntries.add(new BufferBundle.MemoryReport.GridEntry(var4, var5, var3.bufferType));
      }

      class="kw">return var1;
   }

   class="kw">public class="kw">static class Access class="kw">implements MemInstrument {
      @Nonnull
      class="kw">private class="kw">final BufferBundle.Grid grid;
      @Nonnull
      class="kw">private class="kw">final Bounds3i bounds_bufferGrid;
      @Nonnull
      class="kw">private class="kw">final BufferBundle.Grid.TrackedBuffer[] buffers;
      class="kw">private boolean isClosed;

      class="kw">private Access(@Nonnull BufferBundle.Grid var1, @Nonnull Bounds3i var2) {
         assert var2.isCorrect();
         this.grid = var1;
         this.bounds_bufferGrid = var2.clone();
         this.bounds_bufferGrid.min.y = 0;
         this.bounds_bufferGrid.max.y = 40;
         Vector3i var3 = this.bounds_bufferGrid.getSize();
         int var4 = var3.x * var3.y * var3.z;
         this.buffers = new BufferBundle.Grid.TrackedBuffer[var4];
         this.isClosed = false;
      }

      @Nonnull
      class="kw">public BufferBundle.Access.View createView(@Nonnull Bounds3i var1) {
         assert this.bounds_bufferGrid.contains(var1);
         class="kw">return new BufferBundle.Access.View(this, var1);
      }

      @Nonnull
      class="kw">public BufferBundle.Access.View createView() {
         class="kw">return new BufferBundle.Access.View(this, this.bounds_bufferGrid);
      }

      @Nonnull
      class="kw">public BufferBundle.Grid.TrackedBuffer getBuffer(int var1, int var2, int var3) {
         assert !this.isClosed;
         assert this.bounds_bufferGrid.contains(var1, var2, var3);
         int var4 = GridUtils.toIndexFromPositionYXZ(var1, var2, var3, this.bounds_bufferGrid);
         class="kw">return this.buffers[var4];
      }

      @Nonnull
      class="kw">public BufferBundle.Grid.TrackedBuffer getBuffer(@Nonnull Vector3i var1) {
         assert !this.isClosed;
         assert this.bounds_bufferGrid.contains(var1);
         int var2 = GridUtils.toIndexFromPositionYXZ(var1, this.bounds_bufferGrid);
         class="kw">return this.buffers[var2];
      }

      @Nonnull
      class="kw">public Bounds3i getBounds_bufferGrid() {
         class="kw">return this.bounds_bufferGrid.clone();
      }

      class="kw">public void close() {
         this.grid.accessors.remove(this);
         this.isClosed = true;
         Arrays.fill(this.buffers, null);
      }

      @Nonnull
      @Override
      class="kw">public MemInstrument.Report getMemoryUsage() {
         long var1 = 8L + this.bounds_bufferGrid.getMemoryUsage().size_bytes();
         class="kw">return new MemInstrument.Report(var1);
      }

      class="kw">private void loadGrid() {
         assert !this.isClosed;
         assert this.bounds_bufferGrid.min.y == 0 && this.bounds_bufferGrid.max.y == 40;
         Vector3i var1 = new Vector3i(this.bounds_bufferGrid.min);
         var1.y = 0;
         BufferBundle.Grid.TrackedBuffer[] var2 = new BufferBundle.Grid.TrackedBuffer[40];

         for (var1.z = this.bounds_bufferGrid.min.z; var1.z < this.bounds_bufferGrid.max.z; var1.z++) {
            for (var1.x = this.bounds_bufferGrid.min.x; var1.x < this.bounds_bufferGrid.max.x; var1.x++) {
               var1.y = 0;
               this.grid.ensureBufferColumnExists(var1, var2);
               int var3 = 0;

               for (var1.y = 0; var1.y < 40; var1.y++) {
                  int var4 = GridUtils.toIndexFromPositionYXZ(var1, this.bounds_bufferGrid);
                  this.buffers[var4] = var2[var3];
                  var3++;
               }
            }
         }
      }

      class="kw">public class="kw">static class View {
         @Nonnull
         class="kw">private class="kw">final BufferBundle.Access access;
         @Nonnull
         class="kw">private class="kw">final Bounds3i bounds_bufferGrid;

         class="kw">private View(@Nonnull BufferBundle.Access var1, @Nonnull Bounds3i var2) {
            assert var1.bounds_bufferGrid.contains(var2);
            this.access = var1;
            this.bounds_bufferGrid = var2;
         }

         @Nonnull
         class="kw">public BufferBundle.Grid.TrackedBuffer getBuffer(int var1, int var2, int var3) {
            assert !this.access.isClosed;
            assert this.bounds_bufferGrid.contains(var1, var2, var3);
            class="kw">return this.access.getBuffer(var1, var2, var3);
         }

         @Nonnull
         class="kw">public BufferBundle.Grid.TrackedBuffer getBuffer(@Nonnull Vector3i var1) {
            assert !this.access.isClosed;
            assert this.bounds_bufferGrid.contains(var1);
            class="kw">return this.access.getBuffer(var1);
         }

         @Nonnull
         class="kw">public Bounds3i getBounds_bufferGrid() {
            class="kw">return this.bounds_bufferGrid.clone();
         }
      }
   }

   class="kw">public class="kw">static class Grid class="kw">implements MemInstrument {
      @Nonnull
      class="kw">private class="kw">final BufferType bufferType;
      @Nonnull
      class="kw">private class="kw">final Map<Vector3i, BufferBundle.Grid.TrackedBuffer> buffers;
      @Nonnull
      class="kw">private class="kw">final Deque<Vector3i> oldestColumnEntryDeque_bufferGrid;
      class="kw">private class="kw">final int capacity;
      @Nonnull
      class="kw">private class="kw">final List<BufferBundle.Access> accessors;

      class="kw">private Grid(@Nonnull BufferType var1, int var2) {
         this.bufferType = var1;
         this.buffers = new HashMap<>();
         this.oldestColumnEntryDeque_bufferGrid = new ArrayDeque<>();
         this.capacity = Math.max(var2, 0);
         this.accessors = new ArrayList<>();
      }

      @Nonnull
      class="kw">public BufferType getBufferType() {
         class="kw">return this.bufferType;
      }

      @Nonnull
      class="kw">public BufferBundle.Access openAccess(@Nonnull Bounds3i var1) {
         BufferBundle.Access var2 = new BufferBundle.Access(this, var1);
         this.accessors.add(var2);
         var2.loadGrid();
         class="kw">return var2;
      }

      class="kw">public void closeAllAccesses() {
         for (int var1 = this.accessors.size() - 1; var1 >= 0; var1--) {
            BufferBundle.Access var2 = this.accessors.get(var1);
            var2.close();
         }
      }

      @Nonnull
      @Override
      class="kw">public MemInstrument.Report getMemoryUsage() {
         long var1 = 68L;
         var1 += 28L * this.buffers.size();
         var1 += 4L * this.buffers.size();
         var1 += 32L * this.buffers.size();

         for (BufferBundle.Grid.TrackedBuffer var4 : this.buffers.values()) {
            var1 += var4.getMemoryUsage().size_bytes();
         }

         var1 += 8L * this.accessors.size();

         for (BufferBundle.Access var10 : this.accessors) {
            var1 += var10.getMemoryUsage().size_bytes();
         }

         class="kw">return new MemInstrument.Report(var1);
      }

      class="kw">private void ensureBufferColumnExists(@Nonnull Vector3i var1, @Nonnull BufferBundle.Grid.TrackedBuffer[] var2) {
         assert var1.y == 0;
         assert var2.length == 40;
         BufferBundle.Grid.TrackedBuffer var3 = this.buffers.get(var1);
         if (var3 == null) {
            this.createBufferColumn(var1, var2);
         } else {
            Vector3i var4 = new Vector3i(var1);

            for (int var5 = 0; var5 < var2.length; var5++) {
               var4.y = var5 + 0;
               var2[var5] = this.buffers.get(var4);
               assert var2[var5] != null;
            }
         }
      }

      class="kw">private void createBufferColumn(@Nonnull Vector3i var1, @Nonnull BufferBundle.Grid.TrackedBuffer[] var2) {
         assert !this.buffers.containsKey(var1);
         assert var2.length == 40;
         this.tryTrimSurplus(40);
         int var3 = 0;

         for (int var4 = 0; var4 < 40; var4++) {
            Vector3i var5 = new Vector3i(var1.x, var4, var1.z);
            BufferBundle.Tracker var6 = new BufferBundle.Tracker();
            Buffer var7 = this.bufferType.bufferSupplier.get();
            assert this.bufferType.isValid(var7);
            var2[var3] = new BufferBundle.Grid.TrackedBuffer(var6, var7);
            this.buffers.put(var5, var2[var3]);
            var3++;
         }

         Vector3i var8 = new Vector3i(var1.x, 0, var1.z);
         this.oldestColumnEntryDeque_bufferGrid.addLast(var8);
      }

      class="kw">private void tryTrimSurplus(int var1) {
         int var2 = Math.max(0, this.buffers.size() - this.capacity - var1);
         int var3 = var2 == 0 ? 0 : var2 / 40 + 1;

         for (int var4 = 0; var4 < var3; var4++) {
            if (!this.destroyOldestBufferColumn()) {
               class="kw">return;
            }
         }
      }

      class="kw">private boolean destroyOldestBufferColumn() {
         assert !this.oldestColumnEntryDeque_bufferGrid.isEmpty();

         for (int var1 = 0; var1 < this.oldestColumnEntryDeque_bufferGrid.size(); var1++) {
            Vector3i var2 = this.oldestColumnEntryDeque_bufferGrid.removeFirst();
            if (!this.isBufferColumnInAccess(var2)) {
               this.removeBufferColumn(var2);
               class="kw">return true;
            }

            this.oldestColumnEntryDeque_bufferGrid.addLast(var2);
         }

         class="kw">return false;
      }

      class="kw">private void removeBufferColumn(@Nonnull Vector3i var1) {
         assert var1.y == 0;
         Vector3i var2 = new Vector3i(var1);

         for (int var3 = 0; var3 < 40; var3++) {
            var2.y = var3;
            this.buffers.remove(var2);
         }
      }

      class="kw">private boolean isBufferColumnInAccess(@Nonnull Vector3i var1) {
         assert var1.y == 0;

         for (BufferBundle.Access var3 : this.accessors) {
            if (var3.bounds_bufferGrid.contains(var1)) {
               class="kw">return true;
            }
         }

         class="kw">return false;
      }

      class="kw">public record TrackedBuffer(@Nonnull BufferBundle.Tracker tracker, @Nonnull Buffer buffer) class="kw">implements MemInstrument {
         class="kw">public TrackedBuffer {
         }

         @Nonnull
         @Override
         class="kw">public MemInstrument.Report getMemoryUsage() {
            long var1 = 16L + this.tracker.getMemoryUsage().size_bytes() + this.buffer.getMemoryUsage().size_bytes();
            class="kw">return new MemInstrument.Report(var1);
         }
      }
   }

   class="kw">public class="kw">static class MemoryReport {
      @Nonnull
      class="kw">public class="kw">final List<BufferBundle.MemoryReport.GridEntry> gridEntries = new ArrayList<>();

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

      @Nonnull
      @Override
      class="kw">public String toString() {
         this.gridEntries.sort((var0, var1x) -> {
            if (var0.bufferType().index > var1x.bufferType().index) {
               class="kw">return 1;
            } else {
               class="kw">return var0.bufferType().index < var1x.bufferType().index ? -1 : 0;
            }
         });
         StringBuilder var1 = new StringBuilder();
         long var2 = 0L;

         for (BufferBundle.MemoryReport.GridEntry var5 : this.gridEntries) {
            var2 += var5.report.size_bytes();
         }

         var2 /= 1000000L;
         var1.append("Memory Usage Report\n");
         var1.append("Buffers Memory Usage: ").append(var2).append(" mb\n");

         for (BufferBundle.MemoryReport.GridEntry var8 : this.gridEntries) {
            var1.append(var8.toString(1));
         }

         class="kw">return var1.toString();
      }

      class="kw">public record GridEntry(MemInstrument.Report report, int bufferCount, @Nonnull BufferType bufferType) {
         class="kw">public GridEntry {
         }

         @Nonnull
         class="kw">public String toString(int var1) {
            long var2 = this.report.size_bytes() / 1000000L;
            StringBuilder var4 = new StringBuilder();
            var4.append("\t".repeat(var1)).append(this.bufferType.name + " Grid (Index ").append(this.bufferType().index).append("):\n");
            var4.append("\t".repeat(var1 + 1)).append("Memory Footprint: ").append(var2).append(" mb\n");
            var4.append("\t".repeat(var1 + 1)).append("Buffer Count: ").append(this.bufferCount).append("\n");
            class="kw">return var4.toString();
         }
      }
   }

   class="kw">public class="kw">static class Tracker class="kw">implements MemInstrument {
      class="kw">public class="kw">final int INITIAL_STAGE_INDEX = -1;
      class="kw">public int stageIndex = -1;

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

      @Nonnull
      @Override
      class="kw">public MemInstrument.Report getMemoryUsage() {
         class="kw">return new MemInstrument.Report(4L);
      }
   }
}