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

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.component.Component;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.core.modules.LegacyModule;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.util.io.MemorySegmentUtil;
class="kw">import it.unimi.dsi.fastutil.ints.Int2IntFunction;
class="kw">import it.unimi.dsi.fastutil.ints.Int2IntMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2LongMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2LongOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntArrayList;
class="kw">import it.unimi.dsi.fastutil.ints.Int2LongMap.Entry;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import javax.annotation.Nonnull;

class="kw">public class EnvironmentChunk class="kw">implements Component<ChunkStore> {
   class="kw">public class="kw">static class="kw">final BuilderCodec<EnvironmentChunk> CODEC = BuilderCodec.<EnvironmentChunk>builder(EnvironmentChunk.class, EnvironmentChunk::new)
      .addField(new KeyedCodec<>("Data", Codec.BYTE_ARRAY), EnvironmentChunk::deserialize, EnvironmentChunk::serialize)
      .build();
   class="kw">private class="kw">final EnvironmentColumn[] columns = new EnvironmentColumn[1024];
   class="kw">private class="kw">final Int2LongMap counts = new Int2LongOpenHashMap();

   class="kw">public class="kw">static ComponentType<ChunkStore, EnvironmentChunk> getComponentType() {
      class="kw">return LegacyModule.get().getEnvironmentChunkComponentType();
   }

   class="kw">public EnvironmentChunk() {
      this(0);
   }

   class="kw">public EnvironmentChunk(int var1) {
      for (int var2 = 0; var2 < this.columns.length; var2++) {
         this.columns[var2] = new EnvironmentColumn(var1);
      }
   }

   @Nonnull
   @Override
   class="kw">public Component<ChunkStore> clone() {
      EnvironmentChunk var1 = new EnvironmentChunk();

      for (int var2 = 0; var2 < this.columns.length; var2++) {
         var1.columns[var2].copyFrom(this.columns[var2]);
      }

      var1.counts.putAll(this.counts);
      class="kw">return var1;
   }

   class="kw">public int get(int var1, int var2, int var3) {
      class="kw">return this.columns[idx(var1, var3)].get(var2);
   }

   class="kw">public EnvironmentColumn get(int var1, int var2) {
      class="kw">return this.columns[idx(var1, var2)];
   }

   class="kw">public void setColumn(int var1, int var2, int var3) {
      EnvironmentColumn var4 = this.columns[idx(var1, var2)];
      var4.set(var3);
      int var5 = Integer.MIN_VALUE;

      int var6;
      do {
         int var7 = var4.get(var5);
         var6 = var4.getMax(var5);
         int var8 = var6 - var5 + 1;
         this.decrementBlockCount(var7, var8);
      } while (var6 < Integer.MAX_VALUE);

      this.createIfNotExist(var3);
      this.incrementBlockCount(var3, Integer.MAX_VALUE);
      var4.set(var3);
   }

   class="kw">public boolean set(int var1, int var2, int var3, int var4) {
      EnvironmentColumn var5 = this.columns[idx(var1, var3)];
      int var6 = var5.get(var2);
      if (var4 != var6) {
         this.decrementBlockCount(var6, 1L);
         this.createIfNotExist(var4);
         this.incrementBlockCount(var4);
         var5.set(var2, var4);
         class="kw">return true;
      } else {
         class="kw">return false;
      }
   }

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

   class="kw">private void createIfNotExist(int var1) {
      if (!this.counts.containsKey(var1)) {
         this.counts.put(var1, 0L);
      }
   }

   class="kw">private void incrementBlockCount(int var1) {
      this.counts.mergeLong(var1, 1L, Long::sum);
   }

   class="kw">private void incrementBlockCount(int var1, int var2) {
      long var3 = this.counts.get(var1);
      this.counts.put(var1, var3 + var2);
   }

   class="kw">private boolean decrementBlockCount(int var1, long var2) {
      long var4 = this.counts.get(var1);
      if (var4 <= var2) {
         this.counts.remove(var1);
         class="kw">return true;
      } else {
         this.counts.put(var1, var4 - var2);
         class="kw">return false;
      }
   }

   class="kw">private byte[] serialize() {
      int var1 = 4;
      ObjectIterator var2 = this.counts.int2LongEntrySet().iterator();

      while (var2.hasNext()) {
         Entry var3 = (Entry)var2.next();
         Environment var4 = Environment.getAssetMap().getAsset(var3.getIntKey());
         String var5 = var4 != null ? var4.getId() : Environment.UNKNOWN.getId();
         var1 += 4 + MemorySegmentUtil.utf8Size(var5);
      }

      for (int var10 = 0; var10 < this.columns.length; var10++) {
         var1 += 4 + 8 * this.columns[var10].maxys_size() + 4;
      }

      byte[] var11 = new byte[var1];
      MemorySegment var12 = MemorySegment.ofArray(var11);
      var12.set(MemorySegmentUtil.INT_BE, 0L, this.counts.size());
      int var13 = 4;
      ObjectIterator var14 = this.counts.int2LongEntrySet().iterator();

      while (var14.hasNext()) {
         Entry var6 = (Entry)var14.next();
         int var7 = var6.getIntKey();
         Environment var8 = Environment.getAssetMap().getAsset(var7);
         String var9 = var8 != null ? var8.getId() : Environment.UNKNOWN.getId();
         var12.set(MemorySegmentUtil.INT_BE, var13, var7);
         var13 += 4 + MemorySegmentUtil.writeUTF(var12, var13 + 4, var9);
      }

      for (int var15 = 0; var15 < this.columns.length; var15++) {
         var13 += this.columns[var15].serialize(var12, var13);
      }

      class="kw">return var11;
   }

   class="kw">private void deserialize(@Nonnull byte[] var1) {
      MemorySegment var2 = MemorySegment.ofArray(var1);
      this.counts.clear();
      int var3 = var2.get(MemorySegmentUtil.INT_BE, 0L);
      int var4 = 4;
      Int2IntMap var5 = new Int2IntOpenHashMap(var3);

      for (int var6 = 0; var6 < var3; var6++) {
         int var7 = var2.get(MemorySegmentUtil.INT_BE, var4);
         var4 += 4;
         String var8 = MemorySegmentUtil.readUTF(var2, var4);
         var4 += MemorySegmentUtil.utf8Size(var2, var4);
         int var9 = Environment.getIndexOrUnknown(var8, "Failed to find environment '%s' when deserializing environment chunk", var8);
         var5.put(var7, var9);
         this.counts.put(var9, 0L);
      }

      for (int var11 = 0; var11 < this.columns.length; var11++) {
         EnvironmentColumn var12 = this.columns[var11];
         var4 += var12.deserialize(var2, var4, var5);

         for (int var13 = 0; var13 < var12.size(); var13++) {
            this.counts.mergeLong(var12.getValue(var13), 1L, Long::sum);
         }
      }
   }

   class="kw">public byte[] serializeProtocol() {
      int var1 = 0;

      for (int var2 = 0; var2 < this.columns.length; var2++) {
         var1 += 2 + (this.columns[var2].maxys_size() + 1) * 2 * 2;
      }

      byte[] var6 = new byte[var1];
      MemorySegment var3 = MemorySegment.ofArray(var6);
      int var4 = 0;

      for (int var5 = 0; var5 < this.columns.length; var5++) {
         var4 += this.columns[var5].serializeProtocol(var3, var4);
      }

      class="kw">return var6;
   }

   class="kw">public void trim() {
      for (int var1 = 0; var1 < this.columns.length; var1++) {
         this.columns[var1].trim();
      }
   }

   class="kw">private class="kw">static int idx(int var0, int var1) {
      class="kw">return ChunkUtil.indexColumn(var0, var1);
   }

   class="kw">public class="kw">static class BulkWriter {
      class="kw">private class="kw">final EnvironmentChunk.BulkWriter.ColumnWriter[] columnWriters = new EnvironmentChunk.BulkWriter.ColumnWriter[1024];

      class="kw">public BulkWriter() {
         for (int var1 = 0; var1 < this.columnWriters.length; var1++) {
            this.columnWriters[var1] = new EnvironmentChunk.BulkWriter.ColumnWriter();
         }
      }

      @Nonnull
      class="kw">public EnvironmentChunk.BulkWriter.ColumnWriter getColumnWriter(int var1, int var2) {
         assert var1 >= 0 && var1 < 32;
         assert var2 >= 0 && var2 < 32;
         int var3 = EnvironmentChunk.idx(var1, var2);
         class="kw">return this.columnWriters[var3];
      }

      class="kw">public void write(@Nonnull EnvironmentChunk var1) {
         var1.counts.clear();

         for (int var2 = 0; var2 < 32; var2++) {
            for (int var3 = 0; var3 < 32; var3++) {
               int var4 = EnvironmentChunk.idx(var2, var3);
               assert this.columnWriters[var4] != null;
               this.columnWriters[var4].write(var1.columns[var4]);
               transferCounts(this.columnWriters[var4].columnCounts, var1.counts);
            }
         }
      }

      class="kw">private class="kw">static void transferCounts(@Nonnull Int2LongMap var0, @Nonnull Int2LongMap var1) {
         ObjectIterator var2 = var0.int2LongEntrySet().iterator();

         while (var2.hasNext()) {
            Entry var3 = (Entry)var2.next();
            long var4 = var1.getOrDefault(var3.getIntKey(), 0L);
            var1.put(var3.getIntKey(), var4 + var3.getLongValue());
         }
      }

      class="kw">public class="kw">static class ColumnWriter {
         class="kw">private class="kw">final IntArrayList maxYsReversed = new IntArrayList(2);
         class="kw">private class="kw">final IntArrayList valuesReversed = new IntArrayList(2);
         class="kw">private class="kw">final Int2LongMap columnCounts = new Int2LongOpenHashMap(2);

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

         class="kw">public void write(@Nonnull EnvironmentColumn var1) {
            int[] var2 = new int[this.maxYsReversed.size()];
            int[] var3 = new int[this.valuesReversed.size()];
            int var4 = 0;

            for (int var5 = var2.length - 1; var5 >= 0; var4++) {
               var2[var4] = this.maxYsReversed.getInt(var5);
               var5--;
            }

            var4 = 0;

            for (int var7 = var3.length - 1; var7 >= 0; var4++) {
               var3[var4] = this.valuesReversed.getInt(var7);
               var7--;
            }

            var1.resetTo(var2, var3);
         }

         class="kw">public void count(int var1, int var2) {
            long var3 = this.columnCounts.getOrDefault(var1, 0L);
            this.columnCounts.put(var1, var3 + var2);
         }

         class="kw">public void intake(@Nonnull Int2IntFunction var1) {
            int var2 = 319;
            int var3 = 0;
            int var4 = 0;
            int var5 = 0;

            for (int var6 = 319; var6 >= 0; var6--) {
               var4 = var1.applyAsInt(var6);
               if (var6 == 319) {
                  var3 = var4;
                  this.valuesReversed.add(var4);
                  var5++;
               } else if (var4 == var3) {
                  var5++;
               } else {
                  this.maxYsReversed.add(var6);
                  this.valuesReversed.add(var4);
                  this.count(var3, var5);
                  var3 = var4;
                  var5 = 1;
               }
            }

            this.count(var4, var5);
         }
      }
   }
}