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

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.ArrayUtil;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.bounds.Bounds3i;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.engine.performanceinstruments.MemInstrument;
class="kw">import com.hypixel.hytale.math.vector.Vector3iUtil;
class="kw">import java.util.Arrays;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;

class="kw">public class VoxelBuffer<T> class="kw">extends Buffer {
   class="kw">public class="kw">static class="kw">final int BUFFER_SIZE_BITS = 3;
   @Nonnull
   class="kw">public class="kw">static class="kw">final Vector3i SIZE = new Vector3i(8, 8, 8);
   @Nonnull
   class="kw">private class="kw">static class="kw">final Bounds3i bounds = new Bounds3i(Vector3iUtil.ZERO, SIZE);
   @Nonnull
   class="kw">private class="kw">final Class<T> voxelType;
   @Nonnull
   class="kw">private VoxelBuffer.State state;
   @Nullable
   class="kw">private VoxelBuffer.ArrayContents<T> arrayContents;
   @Nullable
   class="kw">private T singleValue;
   @Nullable
   class="kw">private VoxelBuffer<T> referenceBuffer;

   class="kw">public VoxelBuffer(@Nonnull Class<T> var1) {
      this.voxelType = var1;
      this.state = VoxelBuffer.State.EMPTY;
      this.arrayContents = null;
      this.singleValue = null;
      this.referenceBuffer = null;
   }

   @Nullable
   class="kw">public T getVoxelContent(int var1, int var2, int var3) {
      assert bounds.contains(var1, var2, var3);

      class="kw">return (T)(class="kw">switch (this.state) {
         case SINGLE_VALUE -> this.singleValue;
         case ARRAY -> this.arrayContents.array[index(var1, var2, var3)];
         case REFERENCE -> this.referenceBuffer.getVoxelContent(var1, var2, var3);
         class="kw">default -> null;
      });
   }

   @Nullable
   class="kw">public T getVoxelContent(@Nonnull Vector3i var1) {
      assert bounds.contains(var1);

      class="kw">return (T)(class="kw">switch (this.state) {
         case SINGLE_VALUE -> this.singleValue;
         case ARRAY -> this.arrayContents.array[index(var1)];
         case REFERENCE -> this.referenceBuffer.getVoxelContent(var1);
         class="kw">default -> null;
      });
   }

   @Nonnull
   class="kw">public Class<T> getVoxelType() {
      class="kw">return this.voxelType;
   }

   class="kw">public void setVoxelContent(int var1, int var2, int var3, @Nullable T var4) {
      assert bounds.contains(var1, var2, var3);
      class="kw">switch (this.state) {
         case SINGLE_VALUE:
            if (this.singleValue == var4) {
               class="kw">return;
            }

            this.switchFromSingleValueToArray();
            this.setVoxelContent(var1, var2, var3, var4);
            break;
         case ARRAY:
            this.arrayContents.array[index(var1, var2, var3)] = var4;
            break;
         case REFERENCE:
            this.dereference();
            this.setVoxelContent(var1, var2, var3, var4);
            break;
         class="kw">default:
            this.state = VoxelBuffer.State.SINGLE_VALUE;
            this.singleValue = var4;
      }
   }

   class="kw">public void setVoxelContent(@Nonnull Vector3i var1, @Nullable T var2) {
      this.setVoxelContent(var1.x, var1.y, var1.z, var2);
   }

   class="kw">public void reference(@Nonnull VoxelBuffer<T> var1) {
      this.state = VoxelBuffer.State.REFERENCE;
      this.referenceBuffer = this.lastReference(var1);
      this.singleValue = null;
      this.arrayContents = null;
   }

   @Nonnull
   class="kw">private VoxelBuffer<T> lastReference(@Nonnull VoxelBuffer<T> var1) {
      while (var1.state == VoxelBuffer.State.REFERENCE) {
         var1 = var1.referenceBuffer;
      }

      class="kw">return var1;
   }

   @Nonnull
   @Override
   class="kw">public MemInstrument.Report getMemoryUsage() {
      long var1 = 128L;
      var1 += 40L;
      if (this.state == VoxelBuffer.State.ARRAY) {
         var1 += this.arrayContents.getMemoryUsage().size_bytes();
      }

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

   class="kw">private void switchFromSingleValueToArray() {
      assert this.state == VoxelBuffer.State.SINGLE_VALUE;
      this.state = VoxelBuffer.State.ARRAY;
      this.arrayContents = new VoxelBuffer.ArrayContents<>();
      Arrays.fill(this.arrayContents.array, this.singleValue);
      this.singleValue = null;
   }

   class="kw">private void dereference() {
      assert this.state == VoxelBuffer.State.REFERENCE;
      this.state = this.referenceBuffer.state;
      class="kw">switch (this.state) {
         case SINGLE_VALUE:
            this.singleValue = this.referenceBuffer.singleValue;
            break;
         case ARRAY:
            this.arrayContents = new VoxelBuffer.ArrayContents<>();
            ArrayUtil.copy(this.referenceBuffer.arrayContents.array, this.arrayContents.array);
            break;
         case REFERENCE:
            this.referenceBuffer = this.referenceBuffer.referenceBuffer;
            break;
         class="kw">default:
            class="kw">return;
      }
   }

   class="kw">private class="kw">static int index(int var0, int var1, int var2) {
      class="kw">return var1 + var0 * SIZE.y + var2 * SIZE.y * SIZE.x;
   }

   class="kw">private class="kw">static int index(@Nonnull Vector3i var0) {
      class="kw">return var0.y + var0.x * SIZE.y + var0.z * SIZE.y * SIZE.x;
   }

   class="kw">public class="kw">static class ArrayContents<T> class="kw">implements MemInstrument {
      @Nonnull
      class="kw">private class="kw">final T[] array = (T[])(new Object[VoxelBuffer.SIZE.x * VoxelBuffer.SIZE.y * VoxelBuffer.SIZE.z]);

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

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

   class="kw">private enum State {
      EMPTY,
      SINGLE_VALUE,
      ARRAY,
      REFERENCE;

      State() {
      }
   }
}