class="kw">package com.hypixel.hytale.server.core.modules.block;

class="kw">import com.hypixel.hytale.common.plugin.PluginManifest;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.Component;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
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.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
class="kw">import com.hypixel.hytale.component.Resource;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.SystemType;
class="kw">import com.hypixel.hytale.component.data.unknown.UnknownComponents;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.spatial.KDTree;
class="kw">import com.hypixel.hytale.component.spatial.SpatialResource;
class="kw">import com.hypixel.hytale.component.system.HolderSystem;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.event.EventPriority;
class="kw">import com.hypixel.hytale.function.consumer.BiIntConsumer;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.modules.LegacyModule;
class="kw">import com.hypixel.hytale.server.core.modules.block.components.ItemContainerBlock;
class="kw">import com.hypixel.hytale.server.core.modules.block.system.ItemContainerBlockSpatialSystem;
class="kw">import com.hypixel.hytale.server.core.modules.block.system.ItemContainerSystems;
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.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.ChunkColumn;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockComponentSection;
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.events.AddWorldEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.ChunkPreLoadProcessEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.meta.state.BlockMapMarker;
class="kw">import com.hypixel.hytale.server.core.universe.world.meta.state.BlockMapMarkersResource;
class="kw">import com.hypixel.hytale.server.core.universe.world.meta.state.LaunchPad;
class="kw">import com.hypixel.hytale.server.core.universe.world.meta.state.RespawnBlock;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.ints.Int2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.ints.IntArrayList;
class="kw">import it.unimi.dsi.fastutil.ints.IntConsumer;
class="kw">import it.unimi.dsi.fastutil.ints.IntList;
class="kw">import java.util.Objects;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3i;

class="kw">public class BlockModule class="kw">extends JavaPlugin {
   class="kw">public class="kw">static class="kw">final PluginManifest MANIFEST = PluginManifest.corePlugin(BlockModule.class).depends(LegacyModule.class).build();
   class="kw">private class="kw">static BlockModule instance;
   class="kw">private SystemType<ChunkStore, BlockModule.MigrationSystem> migrationSystemType;
   class="kw">private ComponentType<ChunkStore, LaunchPad> launchPadComponentType;
   class="kw">private ComponentType<ChunkStore, RespawnBlock> respawnBlockComponentType;
   class="kw">private ComponentType<ChunkStore, BlockMapMarker> blockMapMarkerComponentType;
   class="kw">private ResourceType<ChunkStore, BlockMapMarkersResource> blockMapMarkersResourceType;
   class="kw">private ComponentType<ChunkStore, ItemContainerBlock> itemContainerBlockComponentType;
   class="kw">private ComponentType<ChunkStore, BlockModule.BlockStateInfo> blockStateInfoComponentType;
   class="kw">private ResourceType<ChunkStore, BlockModule.BlockStateInfoNeedRebuild> blockStateInfoNeedRebuildResourceType;
   class="kw">private ResourceType<ChunkStore, SpatialResource<Ref<ChunkStore>, ChunkStore>> itemContainerSpatialResourceType;

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

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

   @Override
   class="kw">protected void setup() {
      ComponentRegistryProxy var1 = this.getChunkStoreRegistry();
      this.migrationSystemType = var1.registerSystemType(BlockModule.MigrationSystem.class);
      this.blockStateInfoComponentType = var1.registerComponent(BlockModule.BlockStateInfo.class, () -> {
         throw new UnsupportedOperationException();
      });
      var1.registerSystem(new BlockModule.BlockStateInfoRefSystem(this.blockStateInfoComponentType));
      this.launchPadComponentType = var1.registerComponent(LaunchPad.class, "LaunchPad", LaunchPad.CODEC);
      this.respawnBlockComponentType = var1.registerComponent(RespawnBlock.class, "RespawnBlock", RespawnBlock.CODEC);
      var1.registerSystem(new RespawnBlock.OnRemove());
      this.itemContainerBlockComponentType = var1.registerComponent(ItemContainerBlock.class, "ItemContainerBlock", ItemContainerBlock.CODEC);
      var1.registerSystem(new BlockModule.MigrateItemContainer());
      var1.registerSystem(new ItemContainerSystems.OnAddedOrRemoved());
      var1.registerSystem(new ItemContainerSystems.OnReplaced());
      var1.registerSystem(new ItemContainerSystems.OnReplacedHolder());
      this.blockMapMarkerComponentType = var1.registerComponent(BlockMapMarker.class, "BlockMapMarker", BlockMapMarker.CODEC);
      this.blockMapMarkersResourceType = var1.registerResource(BlockMapMarkersResource.class, "BlockMapMarkers", BlockMapMarkersResource.CODEC);
      var1.registerSystem(new BlockMapMarker.OnAddRemove());
      this.getEventRegistry()
         .registerGlobal(
            AddWorldEvent.class,
            var0 -> var0.getWorld().getWorldMapManager().getMarkerProviders().put("blockMapMarkers", BlockMapMarker.MarkerProvider.INSTANCE)
         );
      this.blockStateInfoNeedRebuildResourceType = var1.registerResource(
         BlockModule.BlockStateInfoNeedRebuild.class, BlockModule.BlockStateInfoNeedRebuild::new
      );
      this.itemContainerSpatialResourceType = this.getChunkStoreRegistry().registerSpatialResource(() -> new KDTree<>(Ref::isValid));
      this.getChunkStoreRegistry().registerSystem(new ItemContainerBlockSpatialSystem(this.itemContainerSpatialResourceType));
      this.getChunkStoreRegistry().registerSystem(new BlockModule.ItemContainerStateRefSystem());
      this.getEventRegistry().registerGlobal(EventPriority.EARLY, ChunkPreLoadProcessEvent.class, BlockModule::onChunkPreLoadProcessEnsureBlockEntity);
   }

   class="kw">private class="kw">static void onChunkPreLoadProcessEnsureBlockEntity(@Nonnull ChunkPreLoadProcessEvent var0) {
      if (var0.isNewlyGenerated()) {
         Holder var1 = var0.getHolder();
         ChunkColumn var2 = var1.getComponent(ChunkColumn.getComponentType());
         if (var2 != null) {
            Holder[] var3 = var2.getSectionHolders();
            if (var3 != null) {
               BlockModule.BlockEntityPreprocessor var4 = BlockModule.BlockEntityPreprocessor.LOCAL.get();

               for (int var5 = 0; var5 < 10; var5++) {
                  BlockSection var6 = var3[var5].ensureAndGetComponent(BlockSection.getComponentType());
                  if (!var6.isSolidAir()) {
                     BlockComponentSection var7 = var3[var5].ensureAndGetComponent(BlockComponentSection.getComponentType());
                     var4.clear();
                     var6.forEachValue(var4.typeCollector);
                     if (!var4.ids.isEmpty()) {
                        var6.find(var4.ids, var4.blockCollector);
                        assert var4.indices.size() == var4.blockIds.size();

                        for (int var8 = 0; var8 < var4.indices.size(); var8++) {
                           int var9 = var4.indices.getInt(var8);
                           int var10 = var4.blockIds.getInt(var8);
                           Holder var11 = (Holder<ChunkStore>)var4.blockEntities.get(var10);
                           if (var11 != null && var6.getFiller(var9) == 0 && var7.getBlockHolder(var9) == null) {
                              var7.addBlockHolder(var9, var11.clone());
                           }
                        }
                     }
                  }
               }
            }
         }
      }
   }

   class="kw">public SystemType<ChunkStore, BlockModule.MigrationSystem> getMigrationSystemType() {
      class="kw">return this.migrationSystemType;
   }

   class="kw">public ComponentType<ChunkStore, BlockModule.BlockStateInfo> getBlockStateInfoComponentType() {
      class="kw">return this.blockStateInfoComponentType;
   }

   class="kw">public ComponentType<ChunkStore, LaunchPad> getLaunchPadComponentType() {
      class="kw">return this.launchPadComponentType;
   }

   class="kw">public ComponentType<ChunkStore, RespawnBlock> getRespawnBlockComponentType() {
      class="kw">return this.respawnBlockComponentType;
   }

   class="kw">public ComponentType<ChunkStore, BlockMapMarker> getBlockMapMarkerComponentType() {
      class="kw">return this.blockMapMarkerComponentType;
   }

   class="kw">public ResourceType<ChunkStore, BlockMapMarkersResource> getBlockMapMarkersResourceType() {
      class="kw">return this.blockMapMarkersResourceType;
   }

   class="kw">public ResourceType<ChunkStore, BlockModule.BlockStateInfoNeedRebuild> getBlockStateInfoNeedRebuildResourceType() {
      class="kw">return this.blockStateInfoNeedRebuildResourceType;
   }

   class="kw">public ComponentType<ChunkStore, ItemContainerBlock> getItemContainerBlockComponentType() {
      class="kw">return this.itemContainerBlockComponentType;
   }

   class="kw">public ResourceType<ChunkStore, SpatialResource<Ref<ChunkStore>, ChunkStore>> getItemContainerSpatialResourceType() {
      class="kw">return this.itemContainerSpatialResourceType;
   }

   @Nullable
   class="kw">public class="kw">static Ref<ChunkStore> getBlockEntity(@Nonnull World var0, int var1, int var2, int var3) {
      ChunkStore var4 = var0.getChunkStore();
      Ref var5 = var4.getChunkSectionReferenceAtBlock(var1, var2, var3);
      class="kw">return var5 == null ? null : getBlockEntity(var4.getStore(), var5, var1, var2, var3);
   }

   @Nullable
   class="kw">public class="kw">static Ref<ChunkStore> getBlockEntity(@Nonnull ComponentAccessor<ChunkStore> var0, @Nonnull Ref<ChunkStore> var1, int var2, int var3, int var4) {
      assert coordsInSection(var0, var1, var2, var3, var4) : "block (" + var2 + ", " + var3 + ", " + var4 + ") is outside the given section";
      BlockComponentSection var5 = var0.getComponent(var1, BlockComponentSection.getComponentType());
      if (var5 == null) {
         class="kw">return null;
      }

      Ref var6 = var5.getBlockReference(ChunkUtil.indexBlock(var2, var3, var4));
      class="kw">return var6 != null && var6.isValid() ? var6 : null;
   }

   class="kw">private class="kw">static boolean coordsInSection(@Nonnull ComponentAccessor<ChunkStore> var0, @Nonnull Ref<ChunkStore> var1, int var2, int var3, int var4) {
      ChunkSection var5 = var0.getComponent(var1, ChunkSection.getComponentType());
      class="kw">return var5 == null
         || var5.getX() == ChunkUtil.chunkCoordinate(var2) && var5.getY() == ChunkUtil.chunkCoordinate(var3) && var5.getZ() == ChunkUtil.chunkCoordinate(var4);
   }

   @Nullable
   class="kw">public class="kw">static <T class="kw">extends Component<ChunkStore>> T getComponent(ComponentType<ChunkStore, T> var0, World var1, int var2, int var3, int var4) {
      Store var5 = var1.getChunkStore().getStore();
      Ref var6 = getBlockEntity(var1, var2, var3, var4);
      class="kw">return var6 == null ? null : var5.getComponent(var6, var0);
   }

   class="kw">public class="kw">static class="kw">final class BlockEntityPreprocessor {
      class="kw">public class="kw">static class="kw">final ThreadLocal<BlockModule.BlockEntityPreprocessor> LOCAL = ThreadLocal.withInitial(BlockModule.BlockEntityPreprocessor::new);
      class="kw">public class="kw">final IntList ids = new IntArrayList();
      class="kw">public class="kw">final Int2ObjectMap<Holder<ChunkStore>> blockEntities = new Int2ObjectOpenHashMap();
      class="kw">public class="kw">final IntList indices = new IntArrayList();
      class="kw">public class="kw">final IntList blockIds = new IntArrayList();
      class="kw">public class="kw">final IntConsumer typeCollector = this::collectType;
      class="kw">public class="kw">final BiIntConsumer blockCollector = this::collectBlock;

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

      class="kw">public void clear() {
         this.ids.clear();
         this.blockEntities.clear();
         this.indices.clear();
         this.blockIds.clear();
      }

      class="kw">private void collectType(int var1) {
         BlockType var2 = BlockType.getAssetMap().getAsset(var1);
         if (var2 != null && !var2.isUnknown() && var2.getBlockEntity() != null) {
            this.ids.add(var1);
            this.blockEntities.put(var1, var2.getBlockEntity());
         }
      }

      class="kw">private void collectBlock(int var1, int var2) {
         this.indices.add(var1);
         this.blockIds.add(var2);
      }
   }

   class="kw">public class="kw">static class BlockStateInfo class="kw">implements Component<ChunkStore> {
      class="kw">private class="kw">final int index;
      @Nonnull
      class="kw">private class="kw">final Ref<ChunkStore> sectionRef;

      class="kw">public class="kw">static ComponentType<ChunkStore, BlockModule.BlockStateInfo> getComponentType() {
         class="kw">return BlockModule.get().getBlockStateInfoComponentType();
      }

      class="kw">public BlockStateInfo(int var1, @Nonnull Ref<ChunkStore> var2) {
         Objects.requireNonNull(var2);
         this.index = var1;
         this.sectionRef = var2;
      }

      class="kw">public int getIndex() {
         class="kw">return this.index;
      }

      @Nonnull
      class="kw">public Ref<ChunkStore> getSectionRef() {
         class="kw">return this.sectionRef;
      }

      class="kw">public void markNeedsSaving() {
         if (this.sectionRef.isValid()) {
            this.markNeedsSaving(this.sectionRef.getStore());
         }
      }

      class="kw">public void markNeedsSaving(ComponentAccessor<ChunkStore> var1) {
         if (this.sectionRef.isValid()) {
            BlockComponentSection var2 = var1.getComponent(this.sectionRef, BlockComponentSection.getComponentType());
            if (var2 != null) {
               var2.markBlockNeedsSaving(this.index);
            }
         }
      }

      class="kw">public boolean fillWorldPos(@Nonnull Vector3i var1) {
         class="kw">return !this.sectionRef.isValid() ? false : this.fillWorldPos(this.sectionRef.getStore(), var1);
      }

      class="kw">public boolean fillWorldPos(@Nonnull ComponentAccessor<ChunkStore> var1, @Nonnull Vector3i var2) {
         if (!this.sectionRef.isValid()) {
            class="kw">return false;
         }

         ChunkSection var3 = var1.getComponent(this.sectionRef, ChunkSection.getComponentType());
         if (var3 == null) {
            class="kw">return false;
         }

         var2.set(
            ChunkUtil.worldCoordFromLocalCoord(var3.getX(), ChunkUtil.xFromIndex(this.index)),
            ChunkUtil.worldCoordFromLocalCoord(var3.getY(), ChunkUtil.yFromIndex(this.index)),
            ChunkUtil.worldCoordFromLocalCoord(var3.getZ(), ChunkUtil.zFromIndex(this.index))
         );
         class="kw">return true;
      }

      @Nonnull
      @Override
      class="kw">public Component<ChunkStore> clone() {
         class="kw">return new BlockModule.BlockStateInfo(this.index, this.sectionRef);
      }
   }

   class="kw">public class="kw">static class BlockStateInfoNeedRebuild class="kw">implements Resource<ChunkStore> {
      class="kw">private boolean needRebuild;

      class="kw">public class="kw">static ResourceType<ChunkStore, BlockModule.BlockStateInfoNeedRebuild> getResourceType() {
         class="kw">return BlockModule.get().getBlockStateInfoNeedRebuildResourceType();
      }

      class="kw">public BlockStateInfoNeedRebuild() {
         this.needRebuild = false;
      }

      class="kw">public BlockStateInfoNeedRebuild(boolean var1) {
         this.needRebuild = var1;
      }

      class="kw">public boolean invalidateAndReturnIfNeedRebuild() {
         if (this.needRebuild) {
            this.needRebuild = false;
            class="kw">return true;
         } else {
            class="kw">return false;
         }
      }

      class="kw">public void markAsNeedRebuild() {
         this.needRebuild = true;
      }

      @Override
      class="kw">public Resource<ChunkStore> clone() {
         class="kw">return new BlockModule.BlockStateInfoNeedRebuild(this.needRebuild);
      }
   }

   class="kw">public class="kw">static class BlockStateInfoRefSystem class="kw">extends RefSystem<ChunkStore> {
      @Nonnull
      class="kw">private class="kw">final ComponentType<ChunkStore, BlockModule.BlockStateInfo> blockStateInfoComponentType;

      class="kw">public BlockStateInfoRefSystem(@Nonnull ComponentType<ChunkStore, BlockModule.BlockStateInfo> var1) {
         this.blockStateInfoComponentType = var1;
      }

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

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         BlockModule.BlockStateInfo var5 = var4.getComponent(var1, this.blockStateInfoComponentType);
         assert var5 != null;
         Ref var6 = var5.sectionRef;
         if (var6.isValid()) {
            BlockComponentSection var7 = var4.getComponent(var6, BlockComponentSection.getComponentType());
            if (var7 != null) {
               class="kw">switch (var2) {
                  case SPAWN:
                     var7.addBlockReference(var5.getIndex(), var1);
                     break;
                  case LOAD:
                     var7.loadBlockReference(var5.getIndex(), var1);
               }
            }
         }
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         BlockModule.BlockStateInfo var5 = var4.getComponent(var1, this.blockStateInfoComponentType);
         assert var5 != null;
         Ref var6 = var5.sectionRef;
         if (var6.isValid()) {
            BlockComponentSection var7 = var4.getComponent(var6, BlockComponentSection.getComponentType());
            if (var7 != null) {
               class="kw">switch (var2) {
                  case REMOVE:
                  case BUILDER_TOOLS_UNDO:
                     var7.removeBlockReference(var5.getIndex(), var1);
                     break;
                  case UNLOAD:
                     var7.unloadBlockReference(var5.getIndex(), var1);
               }
            }
         }
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "BlockStateInfoRefSystem{componentType=" + this.blockStateInfoComponentType + "}";
      }
   }

   class="kw">public class="kw">static class ItemContainerStateRefSystem class="kw">extends RefSystem<ChunkStore> {
      class="kw">private class="kw">static class="kw">final Query<ChunkStore> query = ItemContainerBlock.getComponentType();

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

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

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         var4.getExternalData().getWorld().getChunkStore().getStore().getResource(BlockModule.BlockStateInfoNeedRebuild.getResourceType()).markAsNeedRebuild();
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<ChunkStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         var4.getExternalData().getWorld().getChunkStore().getStore().getResource(BlockModule.BlockStateInfoNeedRebuild.getResourceType()).markAsNeedRebuild();
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "ItemContainerStateRefSystem{}";
      }
   }

   class="kw">public class="kw">static class MigrateItemContainer class="kw">extends BlockModule.MigrationSystem {
      class="kw">public MigrateItemContainer() {
      }

      @Override
      class="kw">public void onEntityAdd(@Nonnull Holder<ChunkStore> var1, @Nonnull AddReason var2, @Nonnull Store<ChunkStore> var3) {
         UnknownComponents var4 = var1.getComponent(ChunkStore.REGISTRY.getUnknownComponentType());
         assert var4 != null;
         ItemContainerBlock var5 = var4.removeComponent("container", ItemContainerBlock.CODEC);
         if (var5 != null) {
            var1.putComponent(ItemContainerBlock.getComponentType(), var5);
         }
      }

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

      @Nullable
      @Override
      class="kw">public Query<ChunkStore> getQuery() {
         class="kw">return ChunkStore.REGISTRY.getUnknownComponentType();
      }
   }

   class="kw">public class="kw">abstract class="kw">static class MigrationSystem class="kw">extends HolderSystem<ChunkStore> {
      class="kw">public MigrationSystem() {
      }
   }
}