class="kw">package com.hypixel.hytale.component;

class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.function.consumer.IntObjectConsumer;
class="kw">import java.util.Arrays;
class="kw">import java.util.BitSet;
class="kw">import java.util.function.Consumer;
class="kw">import java.util.function.IntPredicate;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class ArchetypeChunk<ECS_TYPE> {
   @Nonnull
   class="kw">private class="kw">static class="kw">final ArchetypeChunk[] EMPTY_ARRAY = new ArchetypeChunk[0];
   @Nonnull
   class="kw">protected class="kw">final ComponentRegistry<ECS_TYPE> componentRegistry;
   @Nonnull
   class="kw">protected class="kw">final Archetype<ECS_TYPE> archetype;
   class="kw">protected int entitiesSize;
   @Nonnull
   class="kw">protected Ref<ECS_TYPE>[] refs = new Ref[16];
   class="kw">protected Component<ECS_TYPE>[][] components;
   class="kw">private class="kw">final BitSet systemIndexes = new BitSet();
   class="kw">private int archetypeIndex = Integer.MIN_VALUE;

   class="kw">public class="kw">static <ECS_TYPE> ArchetypeChunk<ECS_TYPE>[] emptyArray() {
      class="kw">return EMPTY_ARRAY;
   }

   class="kw">public ArchetypeChunk(@Nonnull Store<ECS_TYPE> var1, @Nonnull Archetype<ECS_TYPE> var2) {
      this.componentRegistry = var1.getRegistry();
      this.archetype = var2;
      this.components = new Component[var2.length()][];

      for (int var3 = var2.getMinIndex(); var3 < var2.length(); var3++) {
         ComponentType var4 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)var2.get(var3);
         if (var4 != null) {
            this.components[var3] = new Component[16];
         }
      }
   }

   @Nonnull
   class="kw">public Archetype<ECS_TYPE> getArchetype() {
      class="kw">return this.archetype;
   }

   class="kw">public int size() {
      class="kw">return this.entitiesSize;
   }

   @Nonnull
   class="kw">public Ref<ECS_TYPE> getReferenceTo(int var1) {
      if (var1 >= 0 && var1 < this.entitiesSize) {
         class="kw">return this.refs[var1];
      } else {
         throw new IndexOutOfBoundsException(var1);
      }
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void setComponent(int var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
      var2.validateRegistry(this.componentRegistry);
      if (var1 < 0 || var1 >= this.entitiesSize) {
         throw new IndexOutOfBoundsException(var1);
      }

      if (!this.archetype.contains(var2)) {
         throw new IllegalArgumentException("Entity doesn't have component type " + var2);
      }

      this.components[var2.getIndex()][var1] = var3;
   }

   @Nullable
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T getComponent(int var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      var2.validateRegistry(this.componentRegistry);
      class="kw">return this.__internal_getComponent(var1, var2);
   }

   @Nullable
   class="kw">protected <T class="kw">extends Component<ECS_TYPE>> T __internal_getComponent(int var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      if (var1 >= 0 && var1 < this.entitiesSize) {
         int var3 = var2.getIndex();
         class="kw">return (T)(!this.archetype.containsAt(var3, var2) ? null : this.components[var3][var1]);
      } else {
         throw new IndexOutOfBoundsException(var1);
      }
   }

   @Nullable
   class="kw">protected <T class="kw">extends Component<ECS_TYPE>> T __internal_getComponentConcurrent(int var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      int var3 = var2.getIndex();
      if (var1 >= 0 && this.archetype.containsAt(var3, var2)) {
         Component[] var4 = this.components[var3];
         class="kw">return (T)(var1 >= var4.length ? null : var4[var1]);
      } else {
         class="kw">return null;
      }
   }

   class="kw">public int addEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2) {
      if (!this.archetype.equals(var2.getArchetype())) {
         throw new IllegalArgumentException("EntityHolder is not for this archetype chunk!");
      }

      int var3 = this.entitiesSize++;
      int var4 = this.refs.length;
      if (var4 <= var3) {
         int var9 = ArrayUtil.grow(var3);
         this.refs = Arrays.copyOf(this.refs, var9);

         for (int var10 = this.archetype.getMinIndex(); var10 < this.archetype.length(); var10++) {
            ComponentType var7 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var10);
            if (var7 != null) {
               Component[] var8 = Arrays.copyOf(this.components[var10], var9);
               var8[var3] = var2.getComponent((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var7);
               this.components[var10] = var8;
            }
         }

         this.refs[var3] = var1;
         class="kw">return var3;
      } else {
         this.refs[var3] = var1;

         for (int var5 = this.archetype.getMinIndex(); var5 < this.archetype.length(); var5++) {
            ComponentType var6 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var5);
            if (var6 != null) {
               this.components[var5][var3] = var2.getComponent((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var6);
            }
         }

         class="kw">return var3;
      }
   }

   class="kw">public void addEntityFrom(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ArchetypeChunk<ECS_TYPE> var2, int var3) {
      this.__internal_addEntity(var1, var2, var3, -1, null);
   }

   class="kw">public void addEntityFrom(
      @Nonnull Ref<ECS_TYPE> var1,
      @Nonnull ArchetypeChunk<ECS_TYPE> var2,
      int var3,
      @Nonnull ComponentType<ECS_TYPE, ?> var4,
      @Nonnull Component<ECS_TYPE> var5
   ) {
      this.__internal_addEntity(var1, var2, var3, var4.getIndex(), var5);
   }

   class="kw">private void __internal_addEntity(
      @Nonnull Ref<ECS_TYPE> var1, @Nonnull ArchetypeChunk<ECS_TYPE> var2, int var3, int var4, @Nullable Component<ECS_TYPE> var5
   ) {
      int var6 = this.entitiesSize++;
      int var7 = var2.entitiesSize - 1;
      var1.beginMutation();
      Ref var8 = var3 != var7 ? var2.refs[var7] : null;
      if (var8 != null) {
         var8.beginMutation();
      }

      if (this.refs.length <= var6) {
         int var9 = ArrayUtil.grow(var6);
         this.refs = Arrays.copyOf(this.refs, var9);
         int var10 = Math.min(this.archetype.getMinIndex(), var2.archetype.getMinIndex());
         int var11 = Math.max(this.archetype.length(), var2.archetype.length());

         for (int var12 = var10; var12 < var11; var12++) {
            boolean var13 = var12 < this.archetype.length() && this.archetype.get(var12) != null;
            boolean var14 = var12 < var2.archetype.length() && var2.archetype.get(var12) != null;
            if (var13) {
               Component[] var15 = Arrays.copyOf(this.components[var12], var9);
               var15[var6] = var12 == var4 ? var5 : var2.components[var12][var3];
               this.components[var12] = var15;
            }

            if (var14) {
               Component[] var20 = var2.components[var12];
               if (var3 != var7) {
                  var20[var3] = var20[var7];
               }

               var20[var7] = null;
            }
         }
      } else {
         if (var3 != var7) {
            for (int var17 = var2.archetype.getMinIndex(); var17 < var2.archetype.length(); var17++) {
               if (var2.archetype.get(var17) != null) {
                  Component[] var19 = var2.components[var17];
                  if (var17 < this.components.length && this.components[var17] != null) {
                     this.components[var17][var6] = var19[var3];
                  }

                  var19[var3] = var19[var7];
                  var19[var7] = null;
               }
            }
         } else {
            for (int var16 = var2.archetype.getMinIndex(); var16 < var2.archetype.length(); var16++) {
               if (var2.archetype.get(var16) != null) {
                  Component[] var18 = var2.components[var16];
                  if (var16 < this.components.length && this.components[var16] != null) {
                     this.components[var16][var6] = var18[var3];
                  }

                  var18[var3] = null;
               }
            }
         }

         if (var4 >= 0) {
            this.components[var4][var6] = var5;
         }
      }

      this.refs[var6] = var1;
      var1.setPosition(this, var6);
      var1.endMutation();
      if (var8 != null) {
         assert var8.isValid() : "movedRef in live chunk range must be valid";
         var8.setPosition(var2, var3);
         var8.endMutation();
         var2.refs[var3] = var8;
      }

      var2.refs[var7] = null;
      var2.entitiesSize = var7;
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> copyEntity(int var1, @Nonnull Holder<ECS_TYPE> var2) {
      if (var1 >= this.entitiesSize) {
         throw new IndexOutOfBoundsException(var1);
      }

      Component[] var3 = var2.ensureComponentsSize(this.archetype.length());

      for (int var4 = this.archetype.getMinIndex(); var4 < this.archetype.length(); var4++) {
         ComponentType var5 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var4);
         if (var5 != null) {
            Component var6 = this.components[var4][var1];
            var3[var4] = var6.clone();
         }
      }

      var2.init(this.archetype, var3);
      class="kw">return var2;
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> copySerializableEntity(
      @Nonnull ComponentRegistry.Data<ECS_TYPE> var1, int var2, @Nonnull Holder<ECS_TYPE> var3, @Nullable Predicate<ComponentType<ECS_TYPE, ?>> var4
   ) {
      if (var2 >= this.entitiesSize) {
         throw new IndexOutOfBoundsException(var2);
      }

      Archetype var5 = this.archetype.getSerializableArchetype(var1, var4);
      Component[] var6 = var3.ensureComponentsSize(var5.length());

      for (int var7 = var5.getMinIndex(); var7 < var5.length(); var7++) {
         ComponentType var8 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)var5.get(var7);
         if (var8 != null) {
            Component var9 = this.components[var7][var2];
            var6[var7] = var9.cloneSerializable();
         }
      }

      var3.init(var5, var6);
      class="kw">return var3;
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> removeEntity(int var1, @Nonnull Holder<ECS_TYPE> var2) {
      if (var1 >= this.entitiesSize) {
         throw new IndexOutOfBoundsException(var1);
      }

      int var3 = this.entitiesSize - 1;
      Component[] var4 = var2.ensureComponentsSize(this.archetype.length());
      if (var1 != var3) {
         Ref var5 = this.refs[var3];
         if (var5.isValid()) {
            var5.beginMutation();
         }

         this.refs[var1] = var5;

         for (int var6 = this.archetype.getMinIndex(); var6 < this.archetype.length(); var6++) {
            ComponentType var7 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var6);
            if (var7 != null) {
               Component[] var8 = this.components[var6];
               var4[var6] = var8[var1];
               var8[var1] = var8[var3];
               var8[var3] = null;
            }
         }

         if (var5.isValid()) {
            var5.setPosition(this, var1);
            var5.endMutation();
         }
      } else {
         for (int var9 = this.archetype.getMinIndex(); var9 < this.archetype.length(); var9++) {
            ComponentType var10 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var9);
            if (var10 != null) {
               Component[] var11 = this.components[var9];
               var4[var9] = var11[var3];
               var11[var3] = null;
            }
         }
      }

      this.refs[var3] = null;
      this.entitiesSize = var3;
      var2.init(this.archetype, var4);
      class="kw">return var2;
   }

   class="kw">public void transferTo(
      @Nonnull Holder<ECS_TYPE> var1,
      @Nonnull ArchetypeChunk<ECS_TYPE> var2,
      @Nonnull Consumer<Holder<ECS_TYPE>> var3,
      @Nonnull IntObjectConsumer<Ref<ECS_TYPE>> var4
   ) {
      Component[] var5 = new Component[this.archetype.length()];

      for (int var6 = 0; var6 < this.entitiesSize; var6++) {
         Ref var7 = this.refs[var6];
         var7.beginMutation();
         this.refs[var6] = null;
         Arrays.fill(var5, 0, this.archetype.getMinIndex(), null);

         for (int var8 = this.archetype.getMinIndex(); var8 < this.archetype.length(); var8++) {
            ComponentType var9 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var8);
            if (var9 == null) {
               var5[var8] = null;
            } else {
               var5[var8] = this.components[var8][var6];
               this.components[var8][var6] = null;
            }
         }

         var1._internal_init(this.archetype, var5, this.componentRegistry.getUnknownComponentType());
         var3.accept(var1);
         int var10 = var2.addEntity(var7, var1);
         var4.accept(var10, var7);
         var7.endMutation();
      }

      this.entitiesSize = 0;
   }

   class="kw">public void transferSomeTo(
      @Nonnull Holder<ECS_TYPE> var1,
      @Nonnull ArchetypeChunk<ECS_TYPE> var2,
      @Nonnull IntPredicate var3,
      @Nonnull Consumer<Holder<ECS_TYPE>> var4,
      @Nonnull IntObjectConsumer<Ref<ECS_TYPE>> var5
   ) {
      int var6 = Integer.MIN_VALUE;
      Component[] var7 = new Component[this.archetype.length()];

      for (int var8 = 0; var8 < this.entitiesSize; var8++) {
         if (var3.test(var8)) {
            if (var6 == Integer.MIN_VALUE) {
               var6 = var8;
            }

            Ref var9 = this.refs[var8];
            var9.beginMutation();
            this.refs[var8] = null;
            Arrays.fill(var7, 0, this.archetype.getMinIndex(), null);

            for (int var10 = this.archetype.getMinIndex(); var10 < this.archetype.length(); var10++) {
               ComponentType var11 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var10);
               if (var11 == null) {
                  var7[var10] = null;
               } else {
                  var7[var10] = this.components[var10][var8];
                  this.components[var10][var8] = null;
               }
            }

            var1.init(this.archetype, var7);
            var4.accept(var1);
            int var15 = var2.addEntity(var9, var1);
            var5.accept(var15, var9);
            var9.endMutation();
         }
      }

      if (var6 != Integer.MIN_VALUE) {
         int var12 = var6;

         for (int var13 = var6 + 1; var13 < this.entitiesSize; var13++) {
            if (this.refs[var13] != null) {
               if (var12 != var13) {
                  this.fillEmptyIndex(var12, var13);
               }

               var12++;
            }
         }

         for (int var14 = var12; var14 < this.entitiesSize; var14++) {
            this.refs[var14] = null;

            for (int var16 = this.archetype.getMinIndex(); var16 < this.archetype.length(); var16++) {
               ComponentType var17 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var16);
               if (var17 != null) {
                  this.components[var16][var14] = null;
               }
            }
         }

         this.entitiesSize = var12;
      }
   }

   class="kw">protected void fillEmptyIndex(int var1, int var2) {
      Ref var3 = this.refs[var2];
      if (var3.isValid()) {
         var3.beginMutation();
      }

      for (int var4 = this.archetype.getMinIndex(); var4 < this.archetype.length(); var4++) {
         ComponentType var5 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var4);
         if (var5 != null) {
            Component[] var6 = this.components[var4];
            var6[var1] = var6[var2];
         }
      }

      this.refs[var1] = var3;
      if (var3.isValid()) {
         var3.setPosition(this, var1);
         var3.endMutation();
      }
   }

   BitSet getSystemIndexes() {
      class="kw">return this.systemIndexes;
   }

   int getArchetypeIndex() {
      class="kw">return this.archetypeIndex;
   }

   void setArchetypeIndex(int var1) {
      this.archetypeIndex = var1;
   }

   class="kw">public void appendDump(@Nonnull String var1, @Nonnull StringBuilder var2) {
      var2.append(var1).append("archetype=").append(this.archetype).append("\n");
      var2.append(var1).append("entitiesSize=").append(this.entitiesSize).append("\n");

      for (int var3 = 0; var3 < this.entitiesSize; var3++) {
         var2.append(var1).append("\t- ").append(this.refs[var3]).append("\n");
         var2.append(var1).append("\t").append("components=").append("\n");

         for (int var4 = this.archetype.getMinIndex(); var4 < this.archetype.length(); var4++) {
            ComponentType var5 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var4);
            if (var5 != null) {
               var2.append(var1).append("\t\t- ").append(var4).append("\t").append(this.components[var4][var3]).append("\n");
            }
         }
      }
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "ArchetypeChunk{archetype="
         + this.archetype
         + ", entitiesSize="
         + this.entitiesSize
         + ", entityReferences="
         + Arrays.toString(this.refs)
         + ", components="
         + Arrays.toString(this.components)
         + "}";
   }
}