class="kw">package com.hypixel.hytale.builtin.fluid;

class="kw">import com.hypixel.hytale.builtin.blocktick.system.ChunkBlockTickSystem;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.dependency.Dependency;
class="kw">import com.hypixel.hytale.component.dependency.Order;
class="kw">import com.hypixel.hytale.component.dependency.RootDependency;
class="kw">import com.hypixel.hytale.component.dependency.SystemDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.tick.EntityTickingSystem;
class="kw">import com.hypixel.hytale.component.system.tick.RunWhenPausedSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.protocol.ToClientPacket;
class="kw">import com.hypixel.hytale.protocol.packets.world.ServerSetFluid;
class="kw">import com.hypixel.hytale.protocol.packets.world.ServerSetFluids;
class="kw">import com.hypixel.hytale.protocol.packets.world.SetFluidCmd;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.Fluid;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.FluidTicker;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.ChunkTracker;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.ChunkSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.FluidSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.ints.IntIterator;
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.objects.ObjectArrayList;
class="kw">import java.util.Collection;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Set;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.function.Function;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;

class="kw">public class FluidSystems {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static class="kw">final int MAX_CHANGES_PER_PACKET = 1024;

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

   class="kw">public class="kw">static class EnsureFluidSection class="kw">extends HolderSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, FluidSection> fluidSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;

      class="kw">public EnsureFluidSection(@Nonnull ComponentType<ChunkStore, ChunkSection> var1, @Nonnull ComponentType<ChunkStore, FluidSection> var2) {
         this.fluidSectionComponentType = var2;
         this.query = Query.and(var1, Query.not(var2));
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3) {
         var1.addComponent(this.fluidSectionComponentType, new FluidSection());
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3) {
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<ChunkStore>> getDependencies() {
         class="kw">return RootDependency.firstSet();
      }
   }

   class="kw">public class="kw">static class LoadPacketGenerator class="kw">extends ChunkStore.LoadFuturePacketDataQuerySystem {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, ChunkSection> chunkSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, FluidSection> fluidSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;

      class="kw">public LoadPacketGenerator(@Nonnull ComponentType<ChunkStore, ChunkSection> var1, @Nonnull ComponentType<ChunkStore, FluidSection> var2) {
         this.chunkSectionComponentType = var1;
         this.fluidSectionComponentType = var2;
         this.query = Query.and(var1, var2);
      }

      class="kw">public void fetch(
         int var1,
         @Nonnull ArchetypeChunk<ChunkStore> var2,
         Store<ChunkStore> var3,
         @Nonnull CommandBuffer<ChunkStore> var4,
         PlayerRef var5,
         @Nonnull List<CompletableFuture<ToClientPacket>> var6
      ) {
         ChunkSection var7 = var2.getComponent(var1, this.chunkSectionComponentType);
         assert var7 != null;
         FluidSection var8 = var2.getComponent(var1, this.fluidSectionComponentType);
         assert var8 != null;
         var6.add(var8.getCachedPacket().exceptionally(var0 -> {
            if (var0 != null) {
               ((HytaleLogger.Api)FluidSystems.LOGGER.at(Level.SEVERE).withCause(var0)).log("Exception when compressing chunk fluids:");
            }

            class="kw">return null;
         }).thenApply(Function.identity()));
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }
   }

   class="kw">public class="kw">static class ReplicateChanges class="kw">extends EntityTickingSystem<ChunkStore> class="kw">implements RunWhenPausedSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, ChunkSection> chunkSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, FluidSection> fluidSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, WorldChunk> worldChunkComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;

      class="kw">public ReplicateChanges(
         @Nonnull ComponentType<ChunkStore, ChunkSection> var1,
         @Nonnull ComponentType<ChunkStore, FluidSection> var2,
         @Nonnull ComponentType<ChunkStore, WorldChunk> var3
      ) {
         this.chunkSectionComponentType = var1;
         this.fluidSectionComponentType = var2;
         this.worldChunkComponentType = var3;
         this.query = Query.and(var1, var2);
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.maybeUseParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(float var1, int var2, @Nonnull ArchetypeChunk<ChunkStore> var3, @Nonnull Store<ChunkStore> var4, @Nonnull CommandBuffer<ChunkStore> var5) {
         FluidSection var6 = var3.getComponent(var2, this.fluidSectionComponentType);
         assert var6 != null;
         IntOpenHashSet var7 = var6.getAndClearChangedPositions();
         if (!var7.isEmpty()) {
            ChunkSection var8 = var3.getComponent(var2, this.chunkSectionComponentType);
            assert var8 != null;
            World var9 = var5.getExternalData().getWorld();
            WorldChunk var10 = var5.getComponent(var8.getChunkColumnReference(), this.worldChunkComponentType);
            int var11 = var8.getX();
            int var12 = var8.getY();
            int var13 = var8.getZ();
            var9.execute(() -> {
               if (var10 != null && var10.getWorld() != null) {
                  var10.getWorld().getChunkLighting().invalidateLightInChunkSection(var4.getExternalData(), var11, var12, var13);
               }
            });
            Collection var14 = var4.getExternalData().getWorld().getPlayerRefs();
            if (var14.isEmpty()) {
               var7.clear();
            } else if (var7.size() >= 1024) {
               ObjectArrayList var27 = new ObjectArrayList(var14);
               var6.getCachedPacket().whenComplete((var4x, var5x) -> {
                  if (var5x != null) {
                     ((HytaleLogger.Api)FluidSystems.LOGGER.at(Level.SEVERE).withCause(var5x)).log("Exception when compressing chunk fluids:");
                  } else {
                     Iterator var6 = var27.iterator();

                     while (var6.hasNext()) {
                        PlayerRef var7 = (PlayerRef)var6.next();
                        Ref var8 = var7.getReference();
                        if (var8 != null && var8.isValid()) {
                           ChunkTracker var9 = var7.getChunkTracker();
                           if (var9.isLoaded(var11, var12, var13)) {
                              var7.getPacketHandler().writeNoCache(var4x);
                           }
                        }
                     }
                  }
               });
               var7.clear();
            } else {
               if (var7.size() == 1) {
                  int var15 = var7.iterator().nextInt();
                  int var16 = ChunkUtil.minBlock(var6.getX()) + ChunkUtil.xFromIndex(var15);
                  int var17 = ChunkUtil.minBlock(var6.getY()) + ChunkUtil.yFromIndex(var15);
                  int var18 = ChunkUtil.minBlock(var6.getZ()) + ChunkUtil.zFromIndex(var15);
                  int var19 = var6.getFluidId(var15);
                  byte var20 = var6.getFluidLevel(var15);
                  ServerSetFluid var21 = new ServerSetFluid(var16, var17, var18, var19, var20);

                  for (PlayerRef var23 : var14) {
                     Ref var24 = var23.getReference();
                     if (var24 != null && var24.isValid()) {
                        ChunkTracker var25 = var23.getChunkTracker();
                        if (var25.isLoaded(var11, var12, var13)) {
                           var23.getPacketHandler().writeNoCache(var21);
                        }
                     }
                  }
               } else {
                  SetFluidCmd[] var26 = new SetFluidCmd[var7.size()];
                  IntIterator var28 = var7.intIterator();
                  int var29 = 0;

                  while (var28.hasNext()) {
                     int var30 = var28.nextInt();
                     int var32 = var6.getFluidId(var30);
                     byte var34 = var6.getFluidLevel(var30);
                     var26[var29++] = new SetFluidCmd((short)var30, var32, var34);
                  }

                  ServerSetFluids var31 = new ServerSetFluids(var6.getX(), var6.getY(), var6.getZ(), var26);

                  for (PlayerRef var35 : var14) {
                     Ref var36 = var35.getReference();
                     if (var36 != null && var36.isValid()) {
                        ChunkTracker var37 = var35.getChunkTracker();
                        if (var37.isLoaded(var11, var12, var13)) {
                           var35.getPacketHandler().writeNoCache(var31);
                        }
                     }
                  }
               }

               var7.clear();
            }
         }
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<ChunkStore>> getDependencies() {
         class="kw">return RootDependency.lastSet();
      }
   }

   class="kw">public class="kw">static class SetupSection class="kw">extends HolderSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, ChunkSection> chunkSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, FluidSection> fluidSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;

      class="kw">public SetupSection(@Nonnull ComponentType<ChunkStore, ChunkSection> var1, @Nonnull ComponentType<ChunkStore, FluidSection> var2) {
         this.chunkSectionComponentType = var1;
         this.fluidSectionComponentType = var2;
         this.query = Query.and(var1, var2);
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3) {
         ChunkSection var4 = var1.getComponent(this.chunkSectionComponentType);
         assert var4 != null;
         FluidSection var5 = var1.getComponent(this.fluidSectionComponentType);
         assert var5 != null;
         var5.load(var4.getX(), var4.getY(), var4.getZ());
      }

      @Override
      class="kw">public void onEntityRemoved(@Nonnull Holder<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3) {
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }
   }

   class="kw">public class="kw">static class Ticking class="kw">extends EntityTickingSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, ChunkSection> chunkSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, FluidSection> fluidSectionComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<ChunkStore> query;
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<ChunkStore>> dependencies = Set.of(
         new SystemDependency<>(Order.AFTER, ChunkBlockTickSystem.PreTick.class), new SystemDependency<>(Order.BEFORE, ChunkBlockTickSystem.Ticking.class)
      );

      class="kw">public Ticking(@Nonnull ComponentType<ChunkStore, ChunkSection> var1, @Nonnull ComponentType<ChunkStore, FluidSection> var2) {
         this.chunkSectionComponentType = var1;
         this.fluidSectionComponentType = var2;
         this.query = Query.and(var2, var1);
      }

      @Override
      class="kw">public boolean isParallel(int var1, int var2) {
         class="kw">return EntityTickingSystem.useParallel(var1, var2);
      }

      @Override
      class="kw">public void tick(float var1, int var2, @Nonnull ArchetypeChunk<ChunkStore> var3, @Nonnull Store<ChunkStore> var4, @Nonnull CommandBuffer<ChunkStore> var5) {
         FluidSection var6 = var3.getComponent(var2, this.fluidSectionComponentType);
         assert var6 != null;
         BlockSection var7 = var3.getComponent(var2, BlockSection.getComponentType());
         if (var7 != null) {
            if (var7.getTickingBlocksCountCopy() != 0) {
               World var8 = var4.getExternalData().getWorld();
               DisabledFluidResource var9 = var4.getResource(DisabledFluidResource.getResourceType());
               IntSet var10 = var9.getDisabledFluidIds(var8.getWorldConfig());
               FluidTicker.CachedAccessor var11 = FluidTicker.CachedAccessor.of(var5, var6, var7, 5);
               var7.forEachTicking(var11, var5, var6.getY(), (var1x, var2x, var3x, var4x, var5x, var6x) -> {
                  FluidSection var7 = var1x.selfFluidSection;
                  BlockSection var8 = var1x.selfBlockSection;
                  int var9 = var7.getFluidId(var3x, var4x, var5x);
                  if (var9 == 0) {
                     class="kw">return BlockTickStrategy.IGNORED;
                  }

                  if (var10.contains(var9)) {
                     class="kw">return BlockTickStrategy.IGNORED;
                  }

                  int var10 = var7.getX() << 5 | var3x;
                  int var11 = var7.getZ() << 5 | var5x;
                  Fluid var12 = Fluid.getAssetMap().getAsset(var9);
                  class="kw">return var12.getTicker().tick(var2x, var1x, var7, var8, var12, var9, var10, var4x, var11);
               });
            }
         }
      }

      @Nonnull
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<ChunkStore>> getDependencies() {
         class="kw">return this.dependencies;
      }
   }
}