class="kw">package com.hypixel.hytale.server.core.universe.world.chunk.section.palette;

class="kw">import com.hypixel.hytale.common.util.BitSetUtil;
class="kw">import com.hypixel.hytale.common.util.BitUtil;
class="kw">import com.hypixel.hytale.function.consumer.BiIntConsumer;
class="kw">import com.hypixel.hytale.math.util.NumberUtil;
class="kw">import com.hypixel.hytale.protocol.packets.world.PaletteType;
class="kw">import com.hypixel.hytale.server.core.util.io.MemorySegmentUtil;
class="kw">import it.unimi.dsi.fastutil.bytes.Byte2ByteMap;
class="kw">import it.unimi.dsi.fastutil.bytes.Byte2ByteOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.bytes.Byte2IntMap;
class="kw">import it.unimi.dsi.fastutil.bytes.Byte2IntOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.bytes.Byte2ShortMap;
class="kw">import it.unimi.dsi.fastutil.bytes.Byte2ShortOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.bytes.ByteSet;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ByteMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ByteOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ShortMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ShortMaps;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ShortOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntIterator;
class="kw">import it.unimi.dsi.fastutil.ints.IntList;
class="kw">import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ShortMap.Entry;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ByteMap;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ByteOpenHashMap;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import java.lang.foreign.ValueLayout;
class="kw">import java.util.BitSet;
class="kw">import java.util.function.IntConsumer;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class="kw">final class ByteSectionPalette class="kw">extends AbstractSectionPalette {
   class="kw">private class="kw">static class="kw">final int KEY_MASK = 255;
   class="kw">public class="kw">static class="kw">final int MAX_SIZE = 256;
   class="kw">public class="kw">static class="kw">final int DEMOTE_SIZE = 14;
   class="kw">final Int2ByteMap externalToInternal;
   class="kw">final Byte2IntMap internalToExternal;
   class="kw">final BitSet internalIdSet;
   class="kw">final Byte2ShortMap internalIdCount;
   class="kw">final byte[] blocks;

   class="kw">public ByteSectionPalette() {
      this.externalToInternal = new Int2ByteOpenHashMap();
      this.internalToExternal = new Byte2IntOpenHashMap();
      this.internalIdSet = new BitSet(256);
      this.internalIdCount = new Byte2ShortOpenHashMap();
      this.blocks = new byte[32768];
      this.externalToInternal.put(0, (byte)0);
      this.internalToExternal.put((byte)0, 0);
      this.internalIdSet.set(0);
      this.internalIdCount.put((byte)0, (short)-32768);
   }

   ByteSectionPalette(Int2ByteMap var1, Byte2IntMap var2, BitSet var3, Byte2ShortMap var4, byte[] var5) {
      this.externalToInternal = var1;
      this.internalToExternal = var2;
      this.internalIdSet = var3;
      this.internalIdCount = var4;
      this.blocks = var5;
   }

   class="kw">public ByteSectionPalette(@Nonnull int[] var1, @Nonnull Int2ShortMap var2) {
      this.blocks = new byte[32768];
      this.externalToInternal = new Int2ByteOpenHashMap(var2.size());
      this.internalToExternal = new Byte2IntOpenHashMap(var2.size());
      this.internalIdSet = new BitSet(var2.size());
      this.internalIdCount = new Byte2ShortOpenHashMap(var2.size());
      byte var3 = 0;

      for (ObjectIterator var4 = Int2ShortMaps.fastIterable(var2).iterator(); var4.hasNext(); var3++) {
         Entry var5 = (Entry)var4.next();
         this.internalToExternal.put(var3, var5.getIntKey());
         this.externalToInternal.put(var5.getIntKey(), var3);
         this.internalIdSet.set(this.unsignedInternalId(var3));
         this.internalIdCount.put(var3, var5.getShortValue());
      }

      int var9 = 0;

      while (var9 < var1.length) {
         int var10 = var1[var9];
         int var6 = var9;

         do {
            var9++;
         } while (var9 < var1.length && var1[var9] == var10);

         byte var7 = this.externalToInternal.get(var10);

         for (int var8 = var6; var8 < var9; var8++) {
            this.blocks[var8] = var7;
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public PaletteType getPaletteType() {
      class="kw">return PaletteType.Byte;
   }

   @Override
   class="kw">public int get(int var1) {
      class="kw">return this.internalToExternal.get(this.blocks[var1]);
   }

   @Nonnull
   @Override
   class="kw">public AbstractSectionPalette.SetResult set(int var1, int var2) {
      byte var3 = this.blocks[var1];
      if (this.externalToInternal.containsKey(var2)) {
         byte var6 = this.externalToInternal.get(var2);
         if (var6 == var3) {
            class="kw">return AbstractSectionPalette.SetResult.UNCHANGED;
         }

         boolean var7 = this.decrementBlockCount(var3);
         this.incrementBlockCount(var6);
         this.blocks[var1] = var6;
         class="kw">return var7 ? AbstractSectionPalette.SetResult.ADDED_OR_REMOVED : AbstractSectionPalette.SetResult.CHANGED;
      } else {
         int var4 = this.nextInternalId(var3);
         if (!this.isValidInternalId(var4)) {
            class="kw">return AbstractSectionPalette.SetResult.REQUIRES_PROMOTE;
         }

         this.decrementBlockCount(var3);
         byte var5 = (byte)var4;
         this.createBlockId(var5, var2);
         this.blocks[var1] = var5;
         class="kw">return AbstractSectionPalette.SetResult.ADDED_OR_REMOVED;
      }
   }

   class="kw">private int nextInternalId(byte var1) {
      class="kw">return this.internalIdCount.get(var1) == 1 ? this.unsignedInternalId(var1) : this.internalIdSet.nextClearBit(0);
   }

   class="kw">private void createBlockId(byte var1, int var2) {
      this.internalToExternal.put(var1, var2);
      this.externalToInternal.put(var2, var1);
      this.internalIdSet.set(this.unsignedInternalId(var1));
      this.internalIdCount.put(var1, (short)1);
   }

   class="kw">private boolean decrementBlockCount(byte var1) {
      short var2 = this.internalIdCount.get(var1);
      if (var2 == 1) {
         this.internalIdCount.remove(var1);
         int var3 = this.internalToExternal.remove(var1);
         this.externalToInternal.remove(var3);
         this.internalIdSet.clear(this.unsignedInternalId(var1));
         class="kw">return true;
      } else {
         this.internalIdCount.mergeShort(var1, (short)1, NumberUtil::subtract);
         class="kw">return false;
      }
   }

   class="kw">private void incrementBlockCount(byte var1) {
      this.internalIdCount.mergeShort(var1, (short)1, NumberUtil::sum);
   }

   @Override
   class="kw">public boolean contains(int var1) {
      class="kw">return this.externalToInternal.containsKey(var1);
   }

   @Override
   class="kw">public boolean containsAny(@Nonnull IntList var1) {
      for (int var2 = 0; var2 < var1.size(); var2++) {
         if (this.externalToInternal.containsKey(var1.getInt(var2))) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   @Override
   class="kw">public int count() {
      class="kw">return this.internalIdCount.size();
   }

   @Override
   class="kw">public int count(int var1) {
      if (this.externalToInternal.containsKey(var1)) {
         byte var2 = this.externalToInternal.get(var1);
         class="kw">return this.internalIdCount.get(var2);
      } else {
         class="kw">return 0;
      }
   }

   @Nonnull
   @Override
   class="kw">public IntSet values() {
      class="kw">return new IntOpenHashSet(this.externalToInternal.keySet());
   }

   @Override
   class="kw">public void forEachValue(@Nonnull IntConsumer var1) {
      this.externalToInternal.keySet().forEach(var1);
   }

   @Nonnull
   @Override
   class="kw">public Int2ShortMap valueCounts() {
      Int2ShortMap var1 = new Int2ShortOpenHashMap();
      ObjectIterator var2 = this.internalIdCount.byte2ShortEntrySet().iterator();

      while (var2.hasNext()) {
         it.unimi.dsi.fastutil.bytes.Byte2ShortMap.Entry var3 = (it.unimi.dsi.fastutil.bytes.Byte2ShortMap.Entry)var2.next();
         byte var4 = var3.getByteKey();
         short var5 = var3.getShortValue();
         int var6 = this.internalToExternal.get(var4);
         var1.put(var6, var5);
      }

      class="kw">return var1;
   }

   @Override
   class="kw">public boolean shouldDemote() {
      class="kw">return this.count() <= 14;
   }

   @Nonnull
   class="kw">public HalfByteSectionPalette demote() {
      class="kw">return HalfByteSectionPalette.fromBytePalette(this);
   }

   @Nonnull
   class="kw">public ShortSectionPalette promote() {
      class="kw">return ShortSectionPalette.fromBytePalette(this);
   }

   class="kw">private boolean isValidInternalId(int var1) {
      class="kw">return (var1 & 0xFF) == var1;
   }

   class="kw">private int unsignedInternalId(byte var1) {
      class="kw">return var1 & 0xFF;
   }

   class="kw">private class="kw">static int sUnsignedInternalId(byte var0) {
      class="kw">return var0 & 0xFF;
   }

   @Override
   class="kw">public void find(@Nonnull IntList var1, @Nonnull IntConsumer var2) {
      ByteSet var3 = this.buildInternalByteSet(var1);
      if (!var3.isEmpty()) {
         int var4 = 0;
         byte var5 = this.blocks[0];

         while (var4 < 32768) {
            int var6 = var4;
            byte var7 = var5;

            do {
               var4++;
            } while (var4 < 32768 && (var5 = this.blocks[var4]) == var7);

            if (var3.contains(var7)) {
               for (int var8 = var6; var8 < var4; var8++) {
                  var2.accept(var8);
               }
            }
         }
      }
   }

   @Override
   class="kw">public void find(@Nonnull IntList var1, @Nonnull BiIntConsumer var2) {
      ByteSet var3 = this.buildInternalByteSet(var1);
      if (!var3.isEmpty()) {
         int var4 = 0;
         byte var5 = this.blocks[0];

         while (var4 < 32768) {
            int var6 = var4;
            byte var7 = var5;

            do {
               var4++;
            } while (var4 < 32768 && (var5 = this.blocks[var4]) == var7);

            if (var3.contains(var7)) {
               int var8 = this.internalToExternal.get(var7);

               for (int var9 = var6; var9 < var4; var9++) {
                  var2.accept(var9, var8);
               }
            }
         }
      }
   }

   class="kw">private ByteSet buildInternalByteSet(IntList var1) {
      ByteSet var2 = PaletteSetProvider.get().getByteSet(var1.size());

      for (int var3 = 0; var3 < var1.size(); var3++) {
         byte var4 = this.externalToInternal.getOrDefault(var1.getInt(var3), (byte)-128);
         if (var4 != -128) {
            var2.add(var4);
         }
      }

      class="kw">return var2;
   }

   @Override
   class="kw">public int serializedPacketByteSize() {
      class="kw">return 2 + 7 * this.internalToExternal.size() + this.blocks.length;
   }

   @Override
   class="kw">public int serializeForPacket(MemorySegment var1, int var2) {
      int var3 = var2;
      var1.set(MemorySegmentUtil.SHORT_LE, var3, (short)this.internalToExternal.size());
      var3 += 2;

      for (ObjectIterator var4 = this.internalToExternal.byte2IntEntrySet().iterator(); var4.hasNext(); var3 += 7) {
         it.unimi.dsi.fastutil.bytes.Byte2IntMap.Entry var5 = (it.unimi.dsi.fastutil.bytes.Byte2IntMap.Entry)var4.next();
         byte var6 = var5.getByteKey();
         int var7 = var5.getIntValue();
         var1.set(ValueLayout.JAVA_BYTE, var3, var6);
         var1.set(MemorySegmentUtil.INT_LE, var3 + 1, var7);
         var1.set(MemorySegmentUtil.SHORT_LE, var3 + 1 + 4, this.internalIdCount.get(var6));
      }

      MemorySegment.copy(this.blocks, 0, var1, ValueLayout.JAVA_BYTE, var3, this.blocks.length);
      var3 += this.blocks.length;
      class="kw">return var3 - var2;
   }

   @Override
   class="kw">public int serializedByteSize(AbstractSectionPalette.KeyMemorySerializer var1) {
      int var2 = 2 + 3 * this.internalToExternal.size() + this.blocks.length;
      IntIterator var3 = this.internalToExternal.values().iterator();

      while (var3.hasNext()) {
         int var4 = (Integer)var3.next();
         var2 += var1.keySize(var4);
      }

      class="kw">return var2;
   }

   @Override
   class="kw">public int serialize(AbstractSectionPalette.KeyMemorySerializer var1, MemorySegment var2, int var3) {
      int var4 = var3;
      var2.set(MemorySegmentUtil.SHORT_BE, var4, (short)this.internalToExternal.size());
      var4 += 2;
      ObjectIterator var5 = this.internalToExternal.byte2IntEntrySet().iterator();

      while (var5.hasNext()) {
         it.unimi.dsi.fastutil.bytes.Byte2IntMap.Entry var6 = (it.unimi.dsi.fastutil.bytes.Byte2IntMap.Entry)var5.next();
         byte var7 = var6.getByteKey();
         int var8 = var6.getIntValue();
         var2.set(ValueLayout.JAVA_BYTE, var4, var7);
         var4 += 1 + var1.serialize(var2, var4 + 1, var8);
         var2.set(MemorySegmentUtil.SHORT_BE, var4, this.internalIdCount.get(var7));
         var4 += 2;
      }

      MemorySegment.copy(this.blocks, 0, var2, ValueLayout.JAVA_BYTE, var4, this.blocks.length);
      var4 += this.blocks.length;
      class="kw">return var4 - var3;
   }

   @Override
   class="kw">public int deserialize(AbstractSectionPalette.KeyMemoryDeserializer var1, MemorySegment var2, int var3) {
      int var4 = var3;
      this.externalToInternal.clear();
      this.internalToExternal.clear();
      this.internalIdSet.clear();
      this.internalIdCount.clear();
      Byte2ByteMap var5 = null;
      int var6 = var2.get(MemorySegmentUtil.SHORT_BE, var4);
      var4 += 2;

      for (int var7 = 0; var7 < var6; var7++) {
         byte var8 = var2.get(ValueLayout.JAVA_BYTE, var4);
         int var9 = var1.deserialize(var2, ++var4);
         var4 += var1.keySize(var2, var4);
         short var10 = var2.get(MemorySegmentUtil.SHORT_BE, var4);
         var4 += 2;
         if (this.externalToInternal.containsKey(var9)) {
            byte var11 = this.externalToInternal.get(var9);
            if (var5 == null) {
               var5 = new Byte2ByteOpenHashMap();
            }

            var5.put(var8, var11);
            this.internalIdCount.mergeShort(var11, var10, NumberUtil::sum);
         } else {
            this.externalToInternal.put(var9, var8);
            this.internalToExternal.put(var8, var9);
            this.internalIdSet.set(this.unsignedInternalId(var8));
            this.internalIdCount.put(var8, var10);
         }
      }

      MemorySegment.copy(var2, ValueLayout.JAVA_BYTE, var4, this.blocks, 0, this.blocks.length);
      var4 += this.blocks.length;
      this.remapBlocks(var5);
      class="kw">return var4 - var3;
   }

   class="kw">private void remapBlocks(@Nullable Byte2ByteMap var1) {
      if (var1 != null) {
         for (int var2 = 0; var2 < 32768; var2++) {
            byte var3 = this.blocks[var2];
            if (var1.containsKey(var3)) {
               this.blocks[var2] = var1.get(var3);
            }
         }
      }
   }

   @Nonnull
   class="kw">public class="kw">static ByteSectionPalette fromHalfBytePalette(@Nonnull HalfByteSectionPalette var0) {
      Int2ByteMap var1 = new Int2ByteOpenHashMap(var0.externalToInternal);
      Byte2IntMap var2 = new Byte2IntOpenHashMap(var0.internalToExternal);
      BitSet var3 = new BitSet(256);
      BitSetUtil.copyValues(var0.internalIdSet, var3);
      Byte2ShortMap var4 = new Byte2ShortOpenHashMap(var0.internalIdCount);
      byte[] var5 = new byte[32768];

      for (int var6 = 0; var6 < 32768; var6++) {
         var5[var6] = BitUtil.getNibble(var0.blocks, var6);
      }

      class="kw">return new ByteSectionPalette(var1, var2, var3, var4, var5);
   }

   @Nonnull
   class="kw">public class="kw">static ByteSectionPalette fromShortPalette(@Nonnull ShortSectionPalette var0) {
      if (var0.count() > 256) {
         throw new IllegalStateException("Cannot demote short palette to byte palette. Too many blocks! Count: " + var0.count());
      }

      Int2ByteMap var1 = new Int2ByteOpenHashMap(var0.count());
      Byte2IntMap var2 = new Byte2IntOpenHashMap(var0.count());
      BitSet var3 = new BitSet(256);
      Byte2ShortMap var4 = new Byte2ShortOpenHashMap(var0.count());
      Short2ByteMap var5 = new Short2ByteOpenHashMap(var0.count());
      byte var6 = 0;
      ObjectIterator var7 = var0.internalToExternal.short2IntEntrySet().iterator();

      while (var7.hasNext()) {
         it.unimi.dsi.fastutil.shorts.Short2IntMap.Entry var8 = (it.unimi.dsi.fastutil.shorts.Short2IntMap.Entry)var7.next();
         short var9 = var8.getShortKey();
         int var10 = var8.getIntValue();
         byte var11 = var6++;
         var2.put(var11, var10);
         var1.put(var10, var11);
         var3.set(sUnsignedInternalId(var11));
         var4.put(var11, var0.internalIdCount.get(var9));
         var5.put(var9, var11);
      }

      byte[] var12 = new byte[32768];

      for (int var13 = 0; var13 < 32768; var13++) {
         short var14 = var0.blocks[var13];
         byte var15 = var5.get(var14);
         var12[var13] = var15;
      }

      class="kw">return new ByteSectionPalette(var1, var2, var3, var4, var12);
   }
}