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

class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.Short2ObjectMapCodec;
class="kw">import com.hypixel.hytale.codec.store.StoredCodec;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.Archetype;
class="kw">import com.hypixel.hytale.component.ArchetypeChunk;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.Component;
class="kw">import com.hypixel.hytale.component.ComponentRegistry;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.NonTicking;
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.query.Query;
class="kw">import com.hypixel.hytale.component.system.RefChangeSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.ToClientPacket;
class="kw">import com.hypixel.hytale.server.core.modules.LegacyModule;
class="kw">import com.hypixel.hytale.server.core.modules.block.BlockModule;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.Savable;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceCollection;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ObjectMaps;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ObjectOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ReferenceMap;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ReferenceMaps;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ReferenceOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.shorts.ShortIterator;
class="kw">import it.unimi.dsi.fastutil.shorts.ShortOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.shorts.ShortSet;
class="kw">import it.unimi.dsi.fastutil.shorts.Short2ObjectMap.Entry;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BlockComponentSection class="kw">extends Savable class="kw">implements Component<ChunkStore> {
   class="kw">public class="kw">static class="kw">final BuilderCodec<BlockComponentSection> CODEC = BuilderCodec.builder(BlockComponentSection.class, BlockComponentSection::new)
      .append(
         new KeyedCodec<>("Blocks", new Short2ObjectMapCodec<>(new StoredCodec<>(ChunkStore.HOLDER_CODEC_KEY), Short2ObjectOpenHashMap::new)),
         (var0, var1) -> {
            var0.blockHolders.clear();
            var0.blockHolders.putAll(var1);
         },
         var0 -> {
            if (var0.blockReferences.isEmpty()) {
               class="kw">return var0.blockHolders;
            }

            Short2ObjectMap var1 = new Short2ObjectOpenHashMap(var0.blockHolders.size() + var0.blockReferences.size());
            var1.putAll(var0.blockHolders);
            Iterator var2 = var0.blockReferences.short2ReferenceEntrySet().iterator();

            while (var2.hasNext()) {
               it.unimi.dsi.fastutil.shorts.Short2ReferenceMap.Entry var3 = (it.unimi.dsi.fastutil.shorts.Short2ReferenceMap.Entry<Ref<ChunkStore>>)var2.next();
               Ref var4 = (Ref<ChunkStore>)var3.getValue();
               Store var5 = var4.getStore();
               if (var5.getArchetype(var4).hasSerializableComponents(var5.getRegistry().getData())) {
                  var1.put(var3.getShortKey(), var5.copySerializableEntity(var4));
               }
            }

            class="kw">return var1;
         }
      )
      .add()
      .build();
   class="kw">private class="kw">final Short2ObjectMap<Holder<ChunkStore>> blockHolders = new Short2ObjectOpenHashMap(0);
   class="kw">private class="kw">final Short2ReferenceMap<Ref<ChunkStore>> blockReferences = new Short2ReferenceOpenHashMap(0);
   class="kw">private class="kw">final Short2ObjectMap<Holder<ChunkStore>> blockHoldersUnmodifiable = Short2ObjectMaps.unmodifiable(this.blockHolders);
   class="kw">private class="kw">final Short2ReferenceMap<Ref<ChunkStore>> blockReferencesUnmodifiable = Short2ReferenceMaps.unmodifiable(this.blockReferences);
   class="kw">private ShortSet dirtyBlocks = new ShortOpenHashSet(0);
   class="kw">private ShortSet removedBlocks = new ShortOpenHashSet(0);
   @Nullable
   class="kw">private ShortSet spareDirtyBlocks;
   @Nullable
   class="kw">private ShortSet spareRemovedBlocks;

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

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

   @Nonnull
   class="kw">public Short2ObjectMap<Holder<ChunkStore>> getBlockHolders() {
      class="kw">return this.blockHoldersUnmodifiable;
   }

   @Nullable
   class="kw">public Holder<ChunkStore> getBlockHolder(int var1) {
      class="kw">return (Holder<ChunkStore>)this.blockHolders.get((short)var1);
   }

   @Nullable
   class="kw">public Holder<ChunkStore> getBlockHolder(short var1) {
      class="kw">return (Holder<ChunkStore>)this.blockHolders.get(var1);
   }

   class="kw">public void addBlockHolder(int var1, @Nonnull Holder<ChunkStore> var2) {
      this.addBlockHolder((short)var1, var2);
   }

   class="kw">public void addBlockHolder(short var1, @Nonnull Holder<ChunkStore> var2) {
      if (this.blockReferences.containsKey(var1)) {
         throw new IllegalArgumentException("Duplicate block components at: " + var1);
      }

      if (this.blockHolders.putIfAbsent(var1, Objects.requireNonNull(var2)) != null) {
         throw new IllegalArgumentException("Duplicate block components (block holder) at: " + var1);
      }

      this.removedBlocks.remove(var1);
      this.dirtyBlocks.add(var1);
      this.markNeedsSaving();
   }

   class="kw">public void storeBlockHolder(int var1, @Nonnull Holder<ChunkStore> var2) {
      this.storeBlockHolder((short)var1, var2);
   }

   class="kw">public void storeBlockHolder(short var1, @Nonnull Holder<ChunkStore> var2) {
      if (this.blockHolders.putIfAbsent(var1, Objects.requireNonNull(var2)) != null) {
         throw new IllegalArgumentException("Duplicate block components (block holder) at: " + var1);
      }

      this.removedBlocks.remove(var1);
   }

   @Nullable
   class="kw">public Holder<ChunkStore> removeBlockHolder(int var1) {
      class="kw">return this.removeBlockHolder((short)var1);
   }

   @Nullable
   class="kw">public Holder<ChunkStore> removeBlockHolder(short var1) {
      Holder var2 = (Holder<ChunkStore>)this.blockHolders.remove(var1);
      if (var2 != null) {
         this.dirtyBlocks.remove(var1);
         this.removedBlocks.add(var1);
         this.markNeedsSaving();
      }

      class="kw">return var2;
   }

   @Nonnull
   class="kw">public Short2ReferenceMap<Ref<ChunkStore>> getBlockReferences() {
      class="kw">return this.blockReferencesUnmodifiable;
   }

   @Nullable
   class="kw">public Ref<ChunkStore> getBlockReference(int var1) {
      class="kw">return (Ref<ChunkStore>)this.blockReferences.get((short)var1);
   }

   @Nullable
   class="kw">public Ref<ChunkStore> getBlockReference(short var1) {
      class="kw">return (Ref<ChunkStore>)this.blockReferences.get(var1);
   }

   class="kw">public void addBlockReference(int var1, @Nonnull Ref<ChunkStore> var2) {
      this.addBlockReference((short)var1, var2);
   }

   class="kw">public void addBlockReference(short var1, @Nonnull Ref<ChunkStore> var2) {
      var2.validate();
      if (this.blockHolders.containsKey(var1)) {
         throw new IllegalArgumentException("Duplicate block components at: " + var1);
      }

      Ref var3 = (Ref<ChunkStore>)this.blockReferences.get(var1);
      if (var3 != null && var3.isValid()) {
         throw new IllegalArgumentException("Duplicate block components (block reference) at: " + var1);
      }

      this.blockReferences.put(var1, Objects.requireNonNull(var2));
      this.removedBlocks.remove(var1);
      this.dirtyBlocks.add(var1);
      this.markNeedsSaving();
   }

   class="kw">public void loadBlockReference(int var1, @Nonnull Ref<ChunkStore> var2) {
      this.loadBlockReference((short)var1, var2);
   }

   class="kw">public void loadBlockReference(short var1, @Nonnull Ref<ChunkStore> var2) {
      var2.validate();
      if (this.blockHolders.containsKey(var1)) {
         throw new IllegalArgumentException("Duplicate block components at: " + var1);
      }

      if (this.blockReferences.putIfAbsent(var1, Objects.requireNonNull(var2)) != null) {
         throw new IllegalArgumentException("Duplicate block components (block reference) at: " + var1);
      }
   }

   class="kw">public void removeBlockReference(int var1, Ref<ChunkStore> var2) {
      this.removeBlockReference((short)var1, var2);
   }

   class="kw">public void removeBlockReference(short var1, Ref<ChunkStore> var2) {
      if (this.blockReferences.remove(var1, var2)) {
         this.dirtyBlocks.remove(var1);
         this.removedBlocks.add(var1);
         this.markNeedsSaving();
      }
   }

   class="kw">public void unloadBlockReference(int var1, Ref<ChunkStore> var2) {
      this.unloadBlockReference((short)var1, var2);
   }

   class="kw">public void unloadBlockReference(short var1, Ref<ChunkStore> var2) {
      this.blockReferences.remove(var1, var2);
   }

   @Nullable
   class="kw">public Short2ObjectMap<Holder<ChunkStore>> takeBlockHolders() {
      if (this.blockHolders.isEmpty()) {
         class="kw">return null;
      }

      Short2ObjectOpenHashMap var1 = new Short2ObjectOpenHashMap(this.blockHolders);
      this.blockHolders.clear();
      class="kw">return var1;
   }

   @Nullable
   class="kw">public Short2ObjectMap<Ref<ChunkStore>> takeBlockReferences() {
      if (this.blockReferences.isEmpty()) {
         class="kw">return null;
      }

      Short2ObjectOpenHashMap var1 = new Short2ObjectOpenHashMap(this.blockReferences);
      this.blockReferences.clear();
      class="kw">return var1;
   }

   class="kw">public boolean hasBlockComponents(int var1) {
      class="kw">return this.hasBlockComponents((short)var1);
   }

   class="kw">public boolean hasBlockComponents(short var1) {
      class="kw">return this.blockReferences.containsKey(var1) || this.blockHolders.containsKey(var1);
   }

   class="kw">public void markBlockNeedsSaving(int var1) {
      this.markBlockNeedsSaving((short)var1);
   }

   class="kw">public void markBlockNeedsSaving(short var1) {
      if (this.hasBlockComponents(var1)) {
         this.dirtyBlocks.add(var1);
         this.markNeedsSaving();
      }
   }

   class="kw">public void markAllBlocksNeedsSaving() {
      if (!this.blockHolders.isEmpty() || !this.blockReferences.isEmpty()) {
         ShortIterator var1 = this.blockHolders.keySet().iterator();

         while (var1.hasNext()) {
            this.dirtyBlocks.add(var1.nextShort());
         }

         var1 = this.blockReferences.keySet().iterator();

         while (var1.hasNext()) {
            this.dirtyBlocks.add(var1.nextShort());
         }

         this.markNeedsSaving();
      }
   }

   class="kw">public void loadBlockHolder(short var1, @Nonnull Holder<ChunkStore> var2) {
      this.blockHolders.put(var1, Objects.requireNonNull(var2));
   }

   class="kw">public void tombstoneBlock(short var1) {
      this.dirtyBlocks.remove(var1);
      this.removedBlocks.add(var1);
      this.markNeedsSaving();
   }

   @Nullable
   class="kw">public ShortSet takeDirtyBlocks() {
      if (this.dirtyBlocks.isEmpty()) {
         class="kw">return null;
      }

      ShortSet var1 = this.dirtyBlocks;
      ShortSet var2 = this.spareDirtyBlocks;
      if (var2 == null) {
         var2 = new ShortOpenHashSet();
      } else {
         var2.clear();
      }

      this.dirtyBlocks = var2;
      this.spareDirtyBlocks = var1;
      class="kw">return var1;
   }

   @Nullable
   class="kw">public ShortSet takeRemovedBlocks() {
      if (this.removedBlocks.isEmpty()) {
         class="kw">return null;
      }

      ShortSet var1 = this.removedBlocks;
      ShortSet var2 = this.spareRemovedBlocks;
      if (var2 == null) {
         var2 = new ShortOpenHashSet();
      } else {
         var2.clear();
      }

      this.removedBlocks = var2;
      this.spareRemovedBlocks = var1;
      class="kw">return var1;
   }

   class="kw">public void restoreSaveFailure(@Nullable ShortSet var1, @Nullable ShortSet var2) {
      if (var2 != null) {
         ShortIterator var3 = var2.iterator();

         while (var3.hasNext()) {
            short var4 = var3.nextShort();
            if (!this.hasBlockComponents(var4)) {
               this.removedBlocks.add(var4);
            }
         }
      }

      if (var1 != null) {
         ShortIterator var5 = var1.iterator();

         while (var5.hasNext()) {
            this.markBlockNeedsSaving(var5.nextShort());
         }
      }

      if (var2 != null || var1 != null) {
         this.markNeedsSaving();
      }
   }

   @Nonnull
   @Override
   class="kw">public Component<ChunkStore> clone() {
      BlockComponentSection var1 = new BlockComponentSection();
      ObjectIterator var2 = this.blockHolders.short2ObjectEntrySet().iterator();

      while (var2.hasNext()) {
         Entry var3 = (Entry<Holder<ChunkStore>>)var2.next();
         var1.blockHolders.put(var3.getShortKey(), ((Holder)var3.getValue()).clone());
      }

      var2 = this.blockReferences.short2ReferenceEntrySet().iterator();

      while (var2.hasNext()) {
         it.unimi.dsi.fastutil.shorts.Short2ReferenceMap.Entry var6 = (it.unimi.dsi.fastutil.shorts.Short2ReferenceMap.Entry<Ref<ChunkStore>>)var2.next();
         Ref var4 = (Ref<ChunkStore>)var6.getValue();
         var1.blockHolders.put(var6.getShortKey(), var4.getStore().copyEntity(var4));
      }

      class="kw">return var1;
   }

   @Nonnull
   @Override
   class="kw">public Component<ChunkStore> cloneSerializable() {
      ComponentRegistry.Data var1 = ChunkStore.REGISTRY.getData();
      BlockComponentSection var2 = new BlockComponentSection();
      ObjectIterator var3 = this.blockHolders.short2ObjectEntrySet().iterator();

      while (var3.hasNext()) {
         Entry var4 = (Entry<Holder<ChunkStore>>)var3.next();
         Holder var5 = (Holder<ChunkStore>)var4.getValue();
         if (var5.getArchetype().hasSerializableComponents(var1)) {
            var2.blockHolders.put(var4.getShortKey(), var5.cloneSerializable(var1));
         }
      }

      var3 = this.blockReferences.short2ReferenceEntrySet().iterator();

      while (var3.hasNext()) {
         it.unimi.dsi.fastutil.shorts.Short2ReferenceMap.Entry var8 = (it.unimi.dsi.fastutil.shorts.Short2ReferenceMap.Entry<Ref<ChunkStore>>)var3.next();
         Ref var9 = (Ref<ChunkStore>)var8.getValue();
         Store var6 = var9.getStore();
         if (var6.getArchetype(var9).hasSerializableComponents(var1)) {
            var2.blockHolders.put(var8.getShortKey(), var6.copySerializableEntity(var9));
         }
      }

      class="kw">return var2;
   }

   class="kw">public class="kw">static class BlockComponentSectionLoadingSystem class="kw">extends RefChangeSystem<ChunkStore, NonTicking<ChunkStore>> {
      class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
      class="kw">private class="kw">final Archetype<ChunkStore> archetype = Archetype.of(ChunkSection.getComponentType(), BlockComponentSection.getComponentType());

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

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

      @Nonnull
      @Override
      class="kw">public ComponentType<ChunkStore, NonTicking<ChunkStore>> componentType() {
         class="kw">return ChunkStore.REGISTRY.getNonTickingComponentType();
      }

      class="kw">public void onComponentAdded(
         @Nonnull Ref<ChunkStore> var1, @Nonnull NonTicking<ChunkStore> var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         BlockComponentSection var5 = var3.getComponent(var1, BlockComponentSection.getComponentType());
         Short2ObjectMap var6 = var5.takeBlockReferences();
         if (var6 != null) {
            ComponentRegistry.Data var7 = ChunkStore.REGISTRY.getData();
            ObjectIterator var8 = var6.short2ObjectEntrySet().iterator();

            while (var8.hasNext()) {
               Entry var9 = (Entry<Ref<ChunkStore>>)var8.next();
               Ref var10 = (Ref<ChunkStore>)var9.getValue();
               if (var3.getArchetype(var10).hasSerializableComponents(var7)) {
                  Holder var11 = ChunkStore.REGISTRY.newHolder();
                  var4.removeEntity(var10, var11, RemoveReason.UNLOAD);
                  var5.storeBlockHolder(var9.getShortKey(), var11);
               } else {
                  var4.removeEntity(var10, RemoveReason.UNLOAD);
               }
            }
         }
      }

      class="kw">public void onComponentSet(
         @Nonnull Ref<ChunkStore> var1,
         NonTicking<ChunkStore> var2,
         @Nonnull NonTicking<ChunkStore> var3,
         @Nonnull Store<ChunkStore> var4,
         @Nonnull CommandBuffer<ChunkStore> var5
      ) {
      }

      class="kw">public void onComponentRemoved(
         @Nonnull Ref<ChunkStore> var1, @Nonnull NonTicking<ChunkStore> var2, @Nonnull Store<ChunkStore> var3, @Nonnull CommandBuffer<ChunkStore> var4
      ) {
         BlockComponentSection var5 = var3.getComponent(var1, BlockComponentSection.getComponentType());
         Short2ObjectMap var6 = var5.takeBlockHolders();
         if (var6 != null) {
            Holder[] var7 = new Holder[var6.size()];
            int var8 = 0;
            ObjectIterator var9 = var6.short2ObjectEntrySet().iterator();

            while (var9.hasNext()) {
               Entry var10 = (Entry<Holder<ChunkStore>>)var9.next();
               Holder var11 = (Holder<ChunkStore>)var10.getValue();
               if (var11.getArchetype().isEmpty()) {
                  LOGGER.at(Level.WARNING).log("Empty archetype entity holder: %s (#%d)", var11, var10.getShortKey());
                  var5.tombstoneBlock(var10.getShortKey());
               } else {
                  var11.putComponent(BlockModule.BlockStateInfo.getComponentType(), new BlockModule.BlockStateInfo(var10.getShortKey(), var1));
                  var7[var8++] = var11;
               }
            }

            if (var8 != 0) {
               var4.addEntities(var7, 0, new Ref[var8], 0, var8, AddReason.LOAD);
            }
         }
      }
   }

   class="kw">public class="kw">static class LoadBlockComponentPacketSystem class="kw">extends ChunkStore.LoadPacketDataQuerySystem {
      class="kw">private class="kw">final ComponentType<ChunkStore, BlockComponentSection> componentType;

      class="kw">public LoadBlockComponentPacketSystem(ComponentType<ChunkStore, BlockComponentSection> var1) {
         this.componentType = var1;
      }

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

      class="kw">public void fetch(
         int var1,
         @Nonnull ArchetypeChunk<ChunkStore> var2,
         @Nonnull Store<ChunkStore> var3,
         CommandBuffer<ChunkStore> var4,
         PlayerRef var5,
         @Nonnull List<ToClientPacket> var6
      ) {
         BlockComponentSection var7 = var2.getComponent(var1, this.componentType);
         ReferenceCollection var8 = var7.blockReferences.values();
         if (!var8.isEmpty()) {
            Store var9 = var3.getExternalData().getWorld().getChunkStore().getStore();
            var9.fetch(var8, ChunkStore.LOAD_PACKETS_DATA_QUERY_SYSTEM_TYPE, var5, var6);
         }
      }
   }

   class="kw">public class="kw">static class UnloadBlockComponentPacketSystem class="kw">extends ChunkStore.UnloadPacketDataQuerySystem {
      class="kw">private class="kw">final ComponentType<ChunkStore, BlockComponentSection> componentType;

      class="kw">public UnloadBlockComponentPacketSystem(ComponentType<ChunkStore, BlockComponentSection> var1) {
         this.componentType = var1;
      }

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

      class="kw">public void fetch(
         int var1,
         @Nonnull ArchetypeChunk<ChunkStore> var2,
         @Nonnull Store<ChunkStore> var3,
         CommandBuffer<ChunkStore> var4,
         PlayerRef var5,
         @Nonnull List<ToClientPacket> var6
      ) {
         BlockComponentSection var7 = var2.getComponent(var1, this.componentType);
         ReferenceCollection var8 = var7.blockReferences.values();
         if (!var8.isEmpty()) {
            Store var9 = var3.getExternalData().getWorld().getChunkStore().getStore();
            var9.fetch(var8, ChunkStore.UNLOAD_PACKETS_DATA_QUERY_SYSTEM_TYPE, var5, var6);
         }
      }
   }
}