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

class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
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.protocol.CachedPacket;
class="kw">import com.hypixel.hytale.protocol.packets.world.SetFluids;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
class="kw">import com.hypixel.hytale.server.core.modules.LegacyModule;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.palette.AbstractSectionPalette;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.palette.EmptySectionPalette;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.palette.PaletteTypeEnum;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import java.lang.foreign.ValueLayout;
class="kw">import java.lang.ref.SoftReference;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.locks.StampedLock;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class FluidSection class="kw">implements Component<ChunkStore> {
   class="kw">public class="kw">static class="kw">final int LEVEL_DATA_SIZE = 16384;
   class="kw">public class="kw">static class="kw">final int VERSION = 0;
   class="kw">public class="kw">static class="kw">final BuilderCodec<FluidSection> CODEC = BuilderCodec.builder(FluidSection.class, FluidSection::new)
      .versioned()
      .codecVersion(0)
      .append(new KeyedCodec<>("Data", Codec.BYTE_ARRAY), FluidSection::deserialize, FluidSection::serialize)
      .add()
      .build();
   class="kw">private class="kw">final StampedLock lock = new StampedLock();
   class="kw">private int x;
   class="kw">private int y;
   class="kw">private int z;
   class="kw">private boolean loaded = false;
   class="kw">private AbstractSectionPalette typePalette = EmptySectionPalette.INSTANCE;
   @Nullable
   class="kw">private byte[] levelData = null;
   class="kw">private int nonZeroLevels = 0;
   @Nonnull
   class="kw">private IntOpenHashSet changedPositions = new IntOpenHashSet(0);
   @Nonnull
   class="kw">private IntOpenHashSet swapChangedPositions = new IntOpenHashSet(0);
   @Nullable
   class="kw">private class="kw">transient SoftReference<CompletableFuture<CachedPacket<SetFluids>>> cachedPacket = null;

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

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

   class="kw">public void preload(int var1, int var2, int var3) {
      this.x = var1;
      this.y = var2;
      this.z = var3;
   }

   class="kw">public void load(int var1, int var2, int var3) {
      this.x = var1;
      this.y = var2;
      this.z = var3;
      this.loaded = true;
   }

   class="kw">private boolean setFluidRaw(int var1, int var2, int var3, int var4) {
      class="kw">return this.setFluidRaw(ChunkUtil.indexBlock(var1, var2, var3), var4);
   }

   class="kw">private boolean setFluidRaw(int var1, int var2) {
      AbstractSectionPalette.SetResult var3 = this.typePalette.set(var1, var2);
      if (var3 == AbstractSectionPalette.SetResult.REQUIRES_PROMOTE) {
         this.typePalette = this.typePalette.promote();
         var3 = this.typePalette.set(var1, var2);
         if (var3 != AbstractSectionPalette.SetResult.ADDED_OR_REMOVED) {
            throw new IllegalStateException("Promoted fluid section failed to correctly add the new fluid");
         }
      } else if (this.typePalette.shouldDemote()) {
         this.typePalette = this.typePalette.demote();
      }

      class="kw">return var3 != AbstractSectionPalette.SetResult.UNCHANGED;
   }

   class="kw">public boolean setFluid(int var1, int var2, int var3, @Nonnull Fluid var4, byte var5) {
      class="kw">return this.setFluid(ChunkUtil.indexBlock(var1, var2, var3), Fluid.getAssetMap().getIndex(var4.getId()), var5);
   }

   class="kw">public boolean setFluid(int var1, int var2, int var3, int var4, byte var5) {
      class="kw">return this.setFluid(ChunkUtil.indexBlock(var1, var2, var3), var4, var5);
   }

   class="kw">public boolean setFluid(int var1, @Nonnull Fluid var2, byte var3) {
      class="kw">return this.setFluid(var1, Fluid.getAssetMap().getIndex(var2.getId()), var3);
   }

   class="kw">public boolean setFluid(int var1, int var2, byte var3) {
      var3 = (byte)(var3 & 15);
      if (var3 == 0) {
         var2 = 0;
      }

      if (var2 == 0) {
         var3 = 0;
      }

      long var4 = this.lock.writeLock();

      try {
         boolean var6 = this.setFluidRaw(var1, var2);
         var6 |= this.setFluidLevel(var1, var3);
         if (var6 && this.loaded) {
            this.cachedPacket = null;
            this.changedPositions.add(var1);
         }

         class="kw">return var6;
      } class="kw">finally {
         this.lock.unlockWrite(var4);
      }
   }

   class="kw">private boolean setFluidRaw(int var1, int var2, int var3, @Nonnull Fluid var4) {
      class="kw">return this.setFluidRaw(ChunkUtil.indexBlock(var1, var2, var3), var4);
   }

   class="kw">private boolean setFluidRaw(int var1, @Nonnull Fluid var2) {
      IndexedLookupTableAssetMap var3 = Fluid.getAssetMap();
      class="kw">return this.setFluidRaw(var1, var3.getIndex(var2.getId()));
   }

   class="kw">public int getFluidId(int var1, int var2, int var3) {
      class="kw">return this.getFluidId(ChunkUtil.indexBlock(var1, var2, var3));
   }

   class="kw">public int getFluidId(int var1) {
      long var2 = this.lock.tryOptimisticRead();
      int var4 = this.typePalette.get(var1);
      if (!this.lock.validate(var2)) {
         var2 = this.lock.readLock();

         try {
            var4 = this.typePalette.get(var1);
         } class="kw">finally {
            this.lock.unlockRead(var2);
         }
      }

      class="kw">return var4;
   }

   @Nullable
   class="kw">public Fluid getFluid(int var1, int var2, int var3) {
      class="kw">return this.getFluid(ChunkUtil.indexBlock(var1, var2, var3));
   }

   @Nullable
   class="kw">public Fluid getFluid(int var1) {
      IndexedLookupTableAssetMap var2 = Fluid.getAssetMap();
      class="kw">return var2.getAsset(this.getFluidId(var1));
   }

   class="kw">private boolean setFluidLevel(int var1, int var2, int var3, byte var4) {
      class="kw">return this.setFluidLevel(ChunkUtil.indexBlock(var1, var2, var3), var4);
   }

   class="kw">private boolean setFluidLevel(int var1, byte var2) {
      var2 = (byte)(var2 & 15);
      if (this.levelData == null) {
         if (var2 == 0) {
            class="kw">return false;
         }

         this.levelData = new byte[16384];
      }

      int var3 = var1 >> 1;
      byte var4 = this.levelData[var3];
      int var5 = var4 >> (var1 & 1) * 4 & 15;
      if (var5 == var2) {
         class="kw">return false;
      }

      if (var5 == 0) {
         this.nonZeroLevels++;
      } else if (var2 == 0) {
         this.nonZeroLevels--;
         if (this.nonZeroLevels <= 0) {
            this.levelData = null;
            class="kw">return true;
         }
      }

      if ((var1 & 1) == 0) {
         this.levelData[var3] = (byte)(var4 & 240 | var2);
      } else {
         this.levelData[var3] = (byte)(var4 & 15 | var2 << 4);
      }

      class="kw">return true;
   }

   class="kw">public byte getFluidLevel(int var1, int var2, int var3) {
      class="kw">return this.getFluidLevel(ChunkUtil.indexBlock(var1, var2, var3));
   }

   class="kw">public byte getFluidLevel(int var1) {
      long var2 = this.lock.tryOptimisticRead();
      byte[] var4 = this.levelData;
      byte var5 = 0;
      if (var4 != null) {
         int var6 = var1 >> 1;
         byte var7 = var4[var6];
         var5 = (byte)(var7 >> (var1 & 1) * 4 & 15);
      }

      if (!this.lock.validate(var2)) {
         var2 = this.lock.readLock();

         try {
            if (this.levelData == null) {
               class="kw">return 0;
            }

            int var13 = var1 >> 1;
            byte var14 = this.levelData[var13];
            class="kw">return (byte)(var14 >> (var1 & 1) * 4 & 15);
         } class="kw">finally {
            this.lock.unlockRead(var2);
         }
      } else {
         class="kw">return var5;
      }
   }

   class="kw">public int getX() {
      class="kw">return this.x;
   }

   class="kw">public int getY() {
      class="kw">return this.y;
   }

   class="kw">public int getZ() {
      class="kw">return this.z;
   }

   @Nonnull
   class="kw">public IntOpenHashSet getAndClearChangedPositions() {
      long var1 = this.lock.writeLock();

      try {
         this.swapChangedPositions.clear();
         IntOpenHashSet var3 = this.changedPositions;
         this.changedPositions = this.swapChangedPositions;
         this.swapChangedPositions = var3;
         class="kw">return var3;
      } class="kw">finally {
         this.lock.unlockWrite(var1);
      }
   }

   @Nonnull
   @Override
   class="kw">public Component<ChunkStore> clone() {
      class="kw">return this;
   }

   class="kw">private byte[] serializeForPacket() {
      long var1 = this.lock.readLock();

      try {
         byte[] var3 = new byte[1 + this.typePalette.serializedPacketByteSize() + 1 + (this.levelData != null ? this.levelData.length : 0)];
         MemorySegment var4 = MemorySegment.ofArray(var3);
         var4.set(ValueLayout.JAVA_BYTE, 0L, (byte)this.typePalette.getPaletteType().ordinal());
         int var5 = 1 + this.typePalette.serializeForPacket(var4, 1);
         if (this.levelData != null) {
            var4.set(ValueLayout.JAVA_BOOLEAN, var5, true);
            MemorySegment.copy(this.levelData, 0, var4, ValueLayout.JAVA_BYTE, var5 + 1, this.levelData.length);
         } else {
            var4.set(ValueLayout.JAVA_BOOLEAN, var5, false);
         }

         class="kw">return var3;
      } class="kw">finally {
         this.lock.unlockRead(var1);
      }
   }

   class="kw">private byte[] serialize(ExtraInfo var1) {
      byte[] var2 = new byte[1 + this.typePalette.serializedByteSize(Fluid.KEY_MEMORY_SERIALIZER) + 1 + (this.levelData != null ? this.levelData.length : 0)];
      MemorySegment var3 = MemorySegment.ofArray(var2);
      long var4 = this.lock.readLock();

      try {
         var3.set(ValueLayout.JAVA_BYTE, 0L, (byte)this.typePalette.getPaletteType().ordinal());
         int var6 = 1 + this.typePalette.serialize(Fluid.KEY_MEMORY_SERIALIZER, var3, 1);
         if (this.levelData != null) {
            var3.set(ValueLayout.JAVA_BOOLEAN, var6, true);
            MemorySegment.copy(this.levelData, 0, var3, ValueLayout.JAVA_BYTE, var6 + 1, this.levelData.length);
         } else {
            var3.set(ValueLayout.JAVA_BOOLEAN, var6, false);
         }
      } class="kw">finally {
         this.lock.unlockRead(var4);
      }

      class="kw">return var2;
   }

   class="kw">private void deserialize(@Nonnull byte[] var1, ExtraInfo var2) {
      MemorySegment var3 = MemorySegment.ofArray(var1);
      PaletteTypeEnum var4 = PaletteTypeEnum.get(var3.get(ValueLayout.JAVA_BYTE, 0L));
      this.typePalette = var4.getConstructor().get();
      int var5 = 1 + this.typePalette.deserialize(Fluid.KEY_MEMORY_DESERIALIZER, var3, 1);
      if (var3.get(ValueLayout.JAVA_BOOLEAN, var5)) {
         this.levelData = var3.asSlice(var5 + 1, 16384L).toArray(ValueLayout.JAVA_BYTE);
         this.nonZeroLevels = 0;

         for (int var6 = 0; var6 < 16384; var6++) {
            byte var7 = this.levelData[var6];
            if ((var7 & 15) != 0) {
               this.nonZeroLevels++;
            }

            if ((var7 & 240) != 0) {
               this.nonZeroLevels++;
            }
         }
      } else {
         this.levelData = null;
      }
   }

   @Nonnull
   class="kw">public CompletableFuture<CachedPacket<SetFluids>> getCachedPacket() {
      SoftReference var1 = this.cachedPacket;
      CompletableFuture var2 = var1 != null ? var1.get() : null;
      if (var2 != null) {
         class="kw">return var2;
      }

      var2 = CompletableFuture.supplyAsync(() -> {
         byte[] var1 = this.serializeForPacket();
         SetFluids var2 = new SetFluids(this.x, this.y, this.z, var1);
         class="kw">return CachedPacket.cache(var2);
      });
      this.cachedPacket = new SoftReference<>(var2);
      class="kw">return var2;
   }

   class="kw">public boolean isEmpty() {
      class="kw">return this.typePalette.isSolid(0) && this.nonZeroLevels == 0;
   }
}