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.ArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.List;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;

class="kw">public class CountedPixelBuffer<T> class="kw">extends PixelBuffer<T> {
   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_VOXEL_GRID = new Vector3i(8, 1, 8);
   @Nonnull
   class="kw">public class="kw">static class="kw">final Bounds3i BOUNDS_VOXEL_GRID = new Bounds3i(Vector3iUtil.ZERO, SIZE_VOXEL_GRID);
   @Nonnull
   class="kw">private class="kw">final Class<T> pixelType;
   @Nonnull
   class="kw">private CountedPixelBuffer.State state;
   @Nullable
   class="kw">private CountedPixelBuffer.CountedArrayContents<T> countedArrayContents;
   @Nullable
   class="kw">private T singleValue;

   class="kw">public CountedPixelBuffer(@Nonnull Class<T> var1) {
      this.pixelType = var1;
      this.state = CountedPixelBuffer.State.EMPTY;
      this.countedArrayContents = null;
      this.singleValue = null;
   }

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

   @Nullable
   @Override
   class="kw">public T getPixelContent(@Nonnull Vector3i var1) {
      assert BOUNDS_VOXEL_GRID.contains(var1);

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

   @Override
   class="kw">public void setPixelContent(@Nonnull Vector3i var1, @Nullable T var2) {
      assert BOUNDS_VOXEL_GRID.contains(var1);
      class="kw">switch (this.state) {
         case SINGLE_VALUE:
            if (this.singleValue == var2) {
               class="kw">return;
            }

            this.switchFromSingleValueToArray();
            this.setPixelContent(var1, var2);
            break;
         case ARRAY:
            this.countedArrayContents.array[index(var1)] = var2;
            if (!this.countedArrayContents.allBiomes.contains(var2)) {
               this.countedArrayContents.allBiomes.add(var2);
            }
            break;
         class="kw">default:
            this.state = CountedPixelBuffer.State.SINGLE_VALUE;
            this.singleValue = var2;
      }
   }

   @Nonnull
   @Override
   class="kw">public Class<T> getPixelType() {
      class="kw">return this.pixelType;
   }

   @Nonnull
   class="kw">public List<T> getUniqueEntries() {
      class="kw">return class="kw">switch (this.state) {
         case SINGLE_VALUE -> List.of(this.singleValue);
         case ARRAY -> {
            assert this.countedArrayContents != null;
            yield this.countedArrayContents.allBiomes;
         }
         class="kw">default -> List.of();
      };
   }

   class="kw">public void copyFrom(@Nonnull CountedPixelBuffer<T> var1) {
      this.state = var1.state;
      class="kw">switch (this.state) {
         case SINGLE_VALUE:
            this.singleValue = var1.singleValue;
            break;
         case ARRAY:
            this.countedArrayContents = new CountedPixelBuffer.CountedArrayContents<>();
            this.countedArrayContents.copyFrom(var1.countedArrayContents);
            break;
         class="kw">default:
            class="kw">return;
      }
   }

   @Nonnull
   @Override
   class="kw">public MemInstrument.Report getMemoryUsage() {
      long var1 = 128L;
      if (this.countedArrayContents != null) {
         var1 += this.countedArrayContents.getMemoryUsage().size_bytes();
      }

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

   class="kw">private void switchFromSingleValueToArray() {
      assert this.state == CountedPixelBuffer.State.SINGLE_VALUE;
      this.state = CountedPixelBuffer.State.ARRAY;
      this.countedArrayContents = new CountedPixelBuffer.CountedArrayContents<>();
      Arrays.fill(this.countedArrayContents.array, this.singleValue);
      this.countedArrayContents.allBiomes.add(this.singleValue);
      this.singleValue = null;
   }

   class="kw">public class="kw">static class CountedArrayContents<T> class="kw">implements MemInstrument {
      @Nonnull
      class="kw">private class="kw">final T[] array = (T[])(new Object[CountedPixelBuffer.SIZE_VOXEL_GRID.x
         * CountedPixelBuffer.SIZE_VOXEL_GRID.y
         * CountedPixelBuffer.SIZE_VOXEL_GRID.z]);
      @Nonnull
      class="kw">private class="kw">final List<T> allBiomes = new ArrayList<>(1);

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

      class="kw">public void copyFrom(@Nonnull CountedPixelBuffer.CountedArrayContents<T> var1) {
         ArrayUtil.copy(var1.array, this.array);
         this.allBiomes.clear();
         this.allBiomes.addAll(var1.allBiomes);
      }

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

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

      State() {
      }
   }
}