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.array.ArrayCodec;
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.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.server.core.entity.Dirty;
class="kw">import com.hypixel.hytale.server.core.modules.LegacyModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
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 com.hypixel.hytale.server.core.universe.world.storage.Savable;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceSet;
class="kw">import it.unimi.dsi.fastutil.objects.ReferenceSets;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
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 EntitySection class="kw">extends Savable class="kw">implements Component<ChunkStore> {
   class="kw">public class="kw">static class="kw">final BuilderCodec<EntitySection> CODEC = BuilderCodec.builder(EntitySection.class, EntitySection::new)
      .append(new KeyedCodec<>("Entities", new ArrayCodec<>(new StoredCodec<>(EntityStore.HOLDER_CODEC_KEY), Holder[]::new)), (var0, var1) -> {
         var0.entityHolders.clear();
         Collections.addAll(var0.entityHolders, var1);
      }, var0 -> {
         if (var0.entityReferences.isEmpty()) {
            class="kw">return var0.entityHolders.toArray(new Holder[var0.entityHolders.size()]);
         }

         Holder[] var1 = new Holder[var0.entityHolders.size() + var0.entityReferences.size()];
         var1 = var0.entityHolders.toArray(var1);
         int var2 = var0.entityHolders.size();
         Iterator var3 = var0.entityReferences.iterator();

         while (var3.hasNext()) {
            Ref var4 = (Ref<EntityStore>)var3.next();
            Store var5 = var4.getStore();
            if (var5.getArchetype(var4).hasSerializableComponents(var5.getRegistry().getData())) {
               var1[var2++] = var5.copySerializableEntity(var4);
            }
         }

         class="kw">return var2 == var1.length ? var1 : Arrays.copyOfRange(var1, 0, var2);
      })
      .add()
      .build();
   @Nonnull
   class="kw">private class="kw">final List<Holder<EntityStore>> entityHolders;
   @Nonnull
   class="kw">private class="kw">final ReferenceSet<Ref<EntityStore>> entityReferences;
   @Nonnull
   class="kw">private class="kw">final List<Holder<EntityStore>> entityHoldersUnmodifiable;
   @Nonnull
   class="kw">private class="kw">final Set<Ref<EntityStore>> entityReferencesUnmodifiable;

   @Nonnull
   class="kw">public class="kw">static ComponentType<ChunkStore, EntitySection> getComponentType() {
      class="kw">return LegacyModule.get().getEntitySectionComponentType();
   }

   class="kw">public EntitySection() {
      this(new ObjectArrayList(), new ReferenceOpenHashSet());
   }

   class="kw">public EntitySection(@Nonnull List<Holder<EntityStore>> var1, @Nonnull ReferenceSet<Ref<EntityStore>> var2) {
      this.entityHolders = var1;
      this.entityReferences = var2;
      this.entityHoldersUnmodifiable = Collections.unmodifiableList(var1);
      this.entityReferencesUnmodifiable = ReferenceSets.unmodifiable(var2);
   }

   @Nonnull
   @Override
   class="kw">public Component<ChunkStore> clone() {
      ObjectArrayList var1 = new ObjectArrayList(this.entityHolders.size() + this.entityReferences.size());

      for (Holder var3 : this.entityHolders) {
         var1.add(var3.clone());
      }

      ObjectIterator var4 = this.entityReferences.iterator();

      while (var4.hasNext()) {
         Ref var5 = (Ref<EntityStore>)var4.next();
         var1.add(var5.getStore().copyEntity(var5));
      }

      class="kw">return new EntitySection(var1, new ReferenceOpenHashSet());
   }

   @Nonnull
   @Override
   class="kw">public Component<ChunkStore> cloneSerializable() {
      ComponentRegistry.Data var1 = EntityStore.REGISTRY.getData();
      ObjectArrayList var2 = new ObjectArrayList(this.entityHolders.size() + this.entityReferences.size());

      for (Holder var4 : this.entityHolders) {
         if (var4.getArchetype().hasSerializableComponents(var1)) {
            var2.add(var4.cloneSerializable(var1));
         }
      }

      ObjectIterator var6 = this.entityReferences.iterator();

      while (var6.hasNext()) {
         Ref var7 = (Ref<EntityStore>)var6.next();
         Store var5 = var7.getStore();
         if (var5.getArchetype(var7).hasSerializableComponents(var1)) {
            var2.add(var5.copySerializableEntity(var7));
         }
      }

      class="kw">return new EntitySection(var2, new ReferenceOpenHashSet());
   }

   @Nonnull
   class="kw">public List<Holder<EntityStore>> getEntityHolders() {
      class="kw">return this.entityHoldersUnmodifiable;
   }

   class="kw">public void addEntityHolder(@Nonnull Holder<EntityStore> var1) {
      this.entityHolders.add(Objects.requireNonNull(var1));
      this.markNeedsSaving();
   }

   class="kw">public void loadEntityHolder(@Nonnull Holder<EntityStore> var1) {
      this.entityHolders.add(Objects.requireNonNull(var1));
   }

   @Nonnull
   class="kw">public Set<Ref<EntityStore>> getEntityReferences() {
      class="kw">return this.entityReferencesUnmodifiable;
   }

   class="kw">public void addEntityReference(@Nonnull Ref<EntityStore> var1) {
      this.entityReferences.add(Objects.requireNonNull(var1));
      this.markNeedsSaving();
   }

   class="kw">public void loadEntityReference(@Nonnull Ref<EntityStore> var1) {
      this.entityReferences.add(Objects.requireNonNull(var1));
   }

   class="kw">public void removeEntityReference(@Nonnull Ref<EntityStore> var1) {
      this.entityReferences.remove(Objects.requireNonNull(var1));
      this.markNeedsSaving();
   }

   class="kw">public void unloadEntityReference(@Nonnull Ref<EntityStore> var1) {
      this.entityReferences.remove(Objects.requireNonNull(var1));
   }

   @Nullable
   class="kw">public Holder<EntityStore>[] takeEntityHolders() {
      if (this.entityHolders.isEmpty()) {
         class="kw">return null;
      }

      Holder[] var1 = this.entityHolders.toArray(Holder[]::new);
      this.entityHolders.clear();
      class="kw">return var1;
   }

   @Nullable
   class="kw">public Ref<EntityStore>[] takeEntityReferences() {
      if (this.entityReferences.isEmpty()) {
         class="kw">return null;
      }

      Ref[] var1 = (Ref<EntityStore>[])this.entityReferences.toArray(Ref[]::new);
      this.entityReferences.clear();
      class="kw">return var1;
   }

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

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

      @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
      ) {
         World var5 = var3.getExternalData().getWorld();
         EntitySection var6 = var3.getComponent(var1, EntitySection.getComponentType());
         assert var6 != null;
         Ref[] var7 = var6.takeEntityReferences();
         if (var7 != null) {
            Store var8 = var5.getEntityStore().getStore();
            Holder[] var9 = var8.removeEntities(var7, RemoveReason.UNLOAD);
            ComponentRegistry.Data var10 = EntityStore.REGISTRY.getData();
            boolean var11 = false;

            for (int var12 = 0; var12 < var9.length; var12++) {
               Holder var13 = var9[var12];
               if (var13.hasSerializableComponents(var10)) {
                  Dirty var14 = var13.getComponent(Dirty.getComponentType());
                  if (var14 != null && var14.isDirty()) {
                     var11 = true;
                  }

                  var6.loadEntityHolder(var13);
               }
            }

            if (var11) {
               var6.markNeedsSaving();
            }
         }
      }

      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
      ) {
         World var5 = var3.getExternalData().getWorld();
         EntitySection var6 = var3.getComponent(var1, EntitySection.getComponentType());
         assert var6 != null;
         Store var7 = var5.getEntityStore().getStore();
         Holder[] var8 = var6.takeEntityHolders();
         if (var8 != null) {
            int var9 = var8.length;

            for (int var10 = var9 - 1; var10 >= 0; var10--) {
               Holder var11 = var8[var10];
               Archetype var12 = var11.getArchetype();
               assert var12 != null;
               if (var12.isEmpty()) {
                  LOGGER.at(Level.SEVERE).log("Empty archetype entity holder: %s (#%d)", var11, var10);
                  var8[var10] = var8[--var9];
                  var8[var9] = var11;
                  var6.markNeedsSaving();
               } else {
                  TransformComponent var13 = var11.getComponent(TransformComponent.getComponentType());
                  if (var13 != null) {
                     var13.setSectionLocation(var1);
                  }
               }
            }

            Ref[] var14 = var7.addEntities(var8, 0, var9, AddReason.LOAD);

            for (int var15 = 0; var15 < var14.length; var15++) {
               Ref var16 = var14[var15];
               if (!var16.isValid()) {
                  break;
               }

               var6.loadEntityReference(var16);
            }
         }
      }
   }
}