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

class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.assetstore.event.LoadedAssetsEvent;
class="kw">import com.hypixel.hytale.assetstore.map.BlockTypeAssetMap;
class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.codec.lookup.Priority;
class="kw">import com.hypixel.hytale.component.ComponentRegistryProxy;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.event.EventPriority;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktick.BlockTickStrategy;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.DefaultFluidTicker;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.FiniteFluidTicker;
class="kw">import com.hypixel.hytale.server.core.asset.type.fluid.FireFluidTicker;
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.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockOperations;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.ChunkColumn;
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.events.ChunkPreLoadProcessEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.ChunkSectionPreLoadProcessEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
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.IntSets;
class="kw">import java.time.Instant;
class="kw">import java.util.Set;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class FluidPlugin class="kw">extends JavaPlugin {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">static FluidPlugin instance;
   class="kw">private ResourceType<ChunkStore, DisabledFluidResource> disabledFluidResourceType;

   class="kw">public class="kw">static FluidPlugin get() {
      class="kw">return instance;
   }

   @Nonnull
   class="kw">public ResourceType<ChunkStore, DisabledFluidResource> getDisabledFluidResourceType() {
      class="kw">return this.disabledFluidResourceType;
   }

   @Nonnull
   class="kw">static IntSet resolveFluidIds(@Nonnull Set<String> var0) {
      IndexedLookupTableAssetMap var1 = Fluid.getAssetMap();
      IntOpenHashSet var2 = new IntOpenHashSet();

      for (String var4 : var0) {
         int var5 = AssetRegistry.getOrCreateTagIndex(var4);
         var2.addAll(var1.getIndexesForTag(var5));
      }

      class="kw">return (IntSet)(var2.isEmpty() ? IntSets.EMPTY_SET : IntSets.unmodifiable(var2));
   }

   class="kw">public FluidPlugin(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
   }

   @Override
   class="kw">protected void setup() {
      ComponentRegistryProxy var1 = this.getChunkStoreRegistry();
      this.disabledFluidResourceType = var1.registerResource(DisabledFluidResource.class, DisabledFluidResource::new);
      FluidTicker.CODEC.register(Priority.DEFAULT, "Default", DefaultFluidTicker.class, DefaultFluidTicker.CODEC);
      FluidTicker.CODEC.register("Fire", FireFluidTicker.class, FireFluidTicker.CODEC);
      FluidTicker.CODEC.register("Finite", FiniteFluidTicker.class, FiniteFluidTicker.CODEC);
      ComponentType var2 = ChunkSection.getComponentType();
      ComponentType var3 = FluidSection.getComponentType();
      ComponentType var4 = WorldChunk.getComponentType();
      var1.registerSystem(new FluidSystems.EnsureFluidSection(var2, var3));
      var1.registerSystem(new FluidSystems.SetupSection(var2, var3));
      var1.registerSystem(new FluidSystems.LoadPacketGenerator(var2, var3));
      var1.registerSystem(new FluidSystems.ReplicateChanges(var2, var3, var4));
      var1.registerSystem(new FluidSystems.Ticking(var2, var3));
      this.getEventRegistry().registerGlobal(EventPriority.FIRST, ChunkPreLoadProcessEvent.class, FluidPlugin::onChunkPreProcess);
      this.getEventRegistry().registerGlobal(EventPriority.FIRST, ChunkSectionPreLoadProcessEvent.class, FluidPlugin::onChunkSectionPreProcess);
      this.getEventRegistry().register(LoadedAssetsEvent.class, Fluid.class, FluidPlugin::onFluidAssetsLoaded);
      this.getCommandRegistry().registerCommand(new FluidCommand());
   }

   class="kw">private class="kw">static void onFluidAssetsLoaded(@Nonnull LoadedAssetsEvent<String, Fluid, IndexedLookupTableAssetMap<String, Fluid>> var0) {
      ResourceType var1 = DisabledFluidResource.getResourceType();

      for (World var3 : Universe.get().getWorlds().values()) {
         var3.execute(() -> var3.getChunkStore().getStore().getResource(var1).invalidate());
      }
   }

   class="kw">private class="kw">static void onChunkPreProcess(@Nonnull ChunkPreLoadProcessEvent var0) {
      if (var0.isNewlyGenerated()) {
         WorldChunk var1 = var0.getChunk();
         Holder var2 = var0.getHolder();
         ChunkColumn var3 = var2.getComponent(ChunkColumn.getComponentType());
         if (var3 != null) {
            BlockChunk var4 = var2.getComponent(BlockChunk.getComponentType());
            if (var4 != null) {
               Holder[] var5 = var3.getSectionHolders();
               if (var5 != null) {
                  int var6 = Math.min(var5.length, 10);
                  ChunkSection[] var7 = new ChunkSection[var6];
                  FluidSection[] var8 = new FluidSection[var6];
                  BlockSection[] var9 = new BlockSection[var6];

                  for (int var10 = 0; var10 < var6; var10++) {
                     Holder var11 = var5[var10];
                     var7[var10] = var11.getComponent(ChunkSection.getComponentType());
                     var8[var10] = var11.ensureAndGetComponent(FluidSection.getComponentType());
                     var9[var10] = var11.ensureAndGetComponent(BlockSection.getComponentType());
                     var8[var10].preload(var1.getX(), var10, var1.getZ());
                  }

                  boolean var17 = !var1.getWorld().getChunkStore().supportsCubicSections();

                  for (int var18 = 0; var18 < var6; var18++) {
                     if (!var8[var18].isEmpty()) {
                        discoverFluids(var8[var18], var9[var18], var18 > 0 ? var8[var18 - 1] : null, var18 > 0 ? var9[var18 - 1] : null, var18 == 0 && var17);
                     }
                  }

                  int var19 = 0;

                  for (BlockSection var15 : var9) {
                     var19 += var15.getTickingBlocksCount();
                  }

                  if (var19 != 0) {
                     FluidPlugin.PreprocessorAccessor var21 = new FluidPlugin.PreprocessorAccessor(
                        var1.getWorld(), var1.getX(), var1.getZ(), 0, var7, var8, var9, var4
                     );

                     do {
                        for (BlockSection var16 : var9) {
                           var16.preTick(Instant.MIN);
                        }

                        for (int var23 = 0; var23 < var6; var23++) {
                           settleSection(var21, var8[var23], var9[var23], var23);
                        }

                        var21.tick++;
                        var19 = 0;

                        for (BlockSection var32 : var9) {
                           var19 += var32.getTickingBlocksCount();
                        }
                     } while (var19 != 0 && var21.tick <= 100L);

                     for (BlockSection var33 : var9) {
                        var33.mergeTickingBlocks();
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">private class="kw">static void onChunkSectionPreProcess(@Nonnull ChunkSectionPreLoadProcessEvent var0) {
      if (var0.isNewlyGenerated()) {
         Holder var1 = var0.getHolder();
         ChunkSection var2 = var1.getComponent(ChunkSection.getComponentType());
         if (var2 != null) {
            int var3 = var2.getY();
            if (var3 < 0 || var3 >= 10) {
               FluidSection var4 = var1.getComponent(FluidSection.getComponentType());
               if (var4 != null && !var4.isEmpty()) {
                  BlockSection var5 = var1.ensureAndGetComponent(BlockSection.getComponentType());
                  var4.preload(var2.getX(), var3, var2.getZ());
                  discoverFluids(var4, var5, null, null, false);
                  if (var5.getTickingBlocksCount() != 0) {
                     FluidPlugin.PreprocessorAccessor var6 = new FluidPlugin.PreprocessorAccessor(
                        var0.getWorld(), var2.getX(), var2.getZ(), var3, new ChunkSection[]{var2}, new FluidSection[]{var4}, new BlockSection[]{var5}, null
                     );

                     do {
                        var5.preTick(Instant.MIN);
                        settleSection(var6, var4, var5, var3);
                        var6.tick++;
                     } while (var5.getTickingBlocksCount() != 0 && var6.tick <= 100L);

                     var5.mergeTickingBlocks();
                  }
               }
            }
         }
      }
   }

   class="kw">private class="kw">static void discoverFluids(
      @Nonnull FluidSection var0, @Nonnull BlockSection var1, @Nullable FluidSection var2, @Nullable BlockSection var3, boolean var4
   ) {
      IndexedLookupTableAssetMap var5 = Fluid.getAssetMap();
      BlockTypeAssetMap var6 = BlockType.getAssetMap();
      int var7 = var0.getY();

      for (int var8 = 0; var8 < 32768; var8++) {
         int var9 = var0.getFluidId(var8);
         if (var9 != 0) {
            Fluid var10 = var5.getAsset(var9);
            if (var10 == null) {
               LOGGER.at(Level.WARNING).log("Invalid fluid found in chunk section: %d, %d %d with id %d", var0.getX(), var7, var0.getZ(), var9);
               var0.setFluid(var8, 0, (byte)0);
            } else if (FluidTicker.isSolid(var6.getAsset(var1.get(var8)))) {
               var0.setFluid(var8, 0, (byte)0);
            } else {
               if (!var10.getTicker().canDemote()) {
                  int var11 = ChunkUtil.minBlock(var0.getX()) + ChunkUtil.xFromIndex(var8);
                  int var12 = ChunkUtil.minBlock(var7) + ChunkUtil.yFromIndex(var8);
                  int var13 = ChunkUtil.minBlock(var0.getZ()) + ChunkUtil.zFromIndex(var8);
                  boolean var14 = ChunkUtil.isBorderBlockGlobal(var11, var13)
                     || var0.getFluidId(var11 - 1, var12, var13) != var9 && !FluidTicker.isSolid(var6.getAsset(var1.get(var11 - 1, var12, var13)))
                     || var0.getFluidId(var11 + 1, var12, var13) != var9 && !FluidTicker.isSolid(var6.getAsset(var1.get(var11 + 1, var12, var13)))
                     || var0.getFluidId(var11, var12, var13 - 1) != var9 && !FluidTicker.isSolid(var6.getAsset(var1.get(var11, var12, var13 - 1)))
                     || var0.getFluidId(var11, var12, var13 + 1) != var9 && !FluidTicker.isSolid(var6.getAsset(var1.get(var11, var12, var13 + 1)));
                  if (!var14) {
                     if (ChunkUtil.chunkCoordinate(var12 - 1) == var7) {
                        var14 = var0.getFluidId(var11, var12 - 1, var13) != var9 && !FluidTicker.isSolid(var6.getAsset(var1.get(var11, var12 - 1, var13)));
                     } else if (var3 != null) {
                        int var15 = var2 == null ? 0 : var2.getFluidId(var11, var12 - 1, var13);
                        var14 = var15 != var9 && !FluidTicker.isSolid(var6.getAsset(var3.get(var11, var12 - 1, var13)));
                     } else if (!var4) {
                        var14 = true;
                     }
                  }

                  if (!var14) {
                     var1.setTicking(var8, false);
                     class="kw">continue;
                  }
               }

               var1.setTicking(var8, true);
            }
         }
      }
   }

   class="kw">private class="kw">static void settleSection(@Nonnull FluidPlugin.PreprocessorAccessor var0, @Nonnull FluidSection var1, @Nonnull BlockSection var2, int var3) {
      if (var2.getTickingBlocksCountCopy() != 0) {
         var2.forEachTicking(var0, var1, var3, (var1x, var2x, var3x, var4, var5, var6) -> {
            int var7 = var2x.getFluidId(var3x, var4, var5);
            if (var7 == 0) {
               class="kw">return BlockTickStrategy.IGNORED;
            }

            int var8 = var2x.getX() << 5 | var3x;
            int var9 = var2x.getZ() << 5 | var5;
            Fluid var10 = Fluid.getAssetMap().getAsset(var7);
            class="kw">return var10.getTicker().process(var1x.world, var1x.tick, var1x, var2x, var2, var10, var7, var8, var4, var9);
         });
      }
   }

   class="kw">public class="kw">static class PreprocessorAccessor class="kw">implements FluidTicker.Accessor {
      @Nonnull
      class="kw">private class="kw">final World world;
      class="kw">private class="kw">final int columnX;
      class="kw">private class="kw">final int columnZ;
      class="kw">private class="kw">final int minSectionY;
      @Nonnull
      class="kw">private class="kw">final ChunkSection[] chunkSections;
      @Nonnull
      class="kw">private class="kw">final FluidSection[] fluidSections;
      @Nonnull
      class="kw">private class="kw">final BlockSection[] blockSections;
      @Nullable
      class="kw">private class="kw">final BlockChunk blockChunk;
      class="kw">private long tick;

      PreprocessorAccessor(
         @Nonnull World var1,
         int var2,
         int var3,
         int var4,
         @Nonnull ChunkSection[] var5,
         @Nonnull FluidSection[] var6,
         @Nonnull BlockSection[] var7,
         @Nullable BlockChunk var8
      ) {
         this.world = var1;
         this.columnX = var2;
         this.columnZ = var3;
         this.minSectionY = var4;
         this.chunkSections = var5;
         this.fluidSections = var6;
         this.blockSections = var7;
         this.blockChunk = var8;
      }

      @Nullable
      @Override
      class="kw">public FluidSection getFluidSection(int var1, int var2, int var3) {
         int var4 = var2 - this.minSectionY;
         class="kw">return var1 == this.columnX && var3 == this.columnZ && var4 >= 0 && var4 < this.fluidSections.length ? this.fluidSections[var4] : null;
      }

      @Nullable
      @Override
      class="kw">public BlockSection getBlockSection(int var1, int var2, int var3) {
         int var4 = var2 - this.minSectionY;
         class="kw">return var1 == this.columnX && var3 == this.columnZ && var4 >= 0 && var4 < this.blockSections.length ? this.blockSections[var4] : null;
      }

      @Override
      class="kw">public void setBlock(int var1, int var2, int var3, int var4) {
         if (ChunkUtil.chunkCoordinate(var1) == this.columnX && ChunkUtil.chunkCoordinate(var3) == this.columnZ) {
            int var5 = ChunkUtil.chunkCoordinate(var2) - this.minSectionY;
            if (var5 >= 0 && var5 < this.blockSections.length) {
               BlockType var6 = BlockType.getAssetMap().getAsset(var4);
               if (var6 != null) {
                  BlockOperations.setBlockPreLoad(this.chunkSections[var5], this.blockSections[var5], this.blockChunk, var1, var2, var3, var4, var6, 0, 0);
               }
            }
         }
      }
   }
}