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

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.ExtraInfo;
class="kw">import com.hypixel.hytale.component.data.change.ComponentChange;
class="kw">import com.hypixel.hytale.component.data.unknown.TempUnknownComponent;
class="kw">import com.hypixel.hytale.component.data.unknown.UnknownComponents;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.locks.StampedLock;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bson.BsonDocument;
class="kw">import org.bson.BsonValue;

class="kw">public class Holder<ECS_TYPE> {
   class="kw">private class="kw">static class="kw">final Holder<?>[] EMPTY_ARRAY = new Holder[0];
   @Nullable
   class="kw">private class="kw">final ComponentRegistry<ECS_TYPE> registry;
   class="kw">private class="kw">final StampedLock lock = new StampedLock();
   class="kw">private Archetype<ECS_TYPE> archetype;
   @Nullable
   class="kw">private Component<ECS_TYPE>[] components;
   class="kw">private boolean ensureValidComponents = true;

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

   Holder() {
      this.registry = null;
   }

   Holder(@Nonnull ComponentRegistry<ECS_TYPE> var1) {
      this.registry = var1;
      this.archetype = Archetype.empty();
      this.components = Component.EMPTY_ARRAY;
   }

   Holder(@Nonnull ComponentRegistry<ECS_TYPE> var1, @Nonnull Archetype<ECS_TYPE> var2, @Nonnull Component<ECS_TYPE>[] var3) {
      this.registry = var1;
      this.init(var2, var3);
   }

   @Nonnull
   class="kw">public Component<ECS_TYPE>[] ensureComponentsSize(int var1) {
      long var2 = this.lock.writeLock();

      try {
         if (this.components == null) {
            this.components = new Component[var1];
            class="kw">return this.components;
         }

         if (this.components.length < var1) {
            this.components = Arrays.copyOf(this.components, var1);
         }

         class="kw">return this.components;
      } class="kw">finally {
         this.lock.unlockWrite(var2);
      }
   }

   class="kw">public void init(@Nonnull Archetype<ECS_TYPE> var1, @Nonnull Component<ECS_TYPE>[] var2) {
      var1.validate();
      var1.validateComponents(var2, null);
      long var3 = this.lock.writeLock();

      try {
         this.archetype = var1;
         this.components = var2;
         this.ensureValidComponents = true;
      } class="kw">finally {
         this.lock.unlockWrite(var3);
      }
   }

   class="kw">public void _internal_init(
      @Nonnull Archetype<ECS_TYPE> var1, @Nonnull Component<ECS_TYPE>[] var2, @Nonnull ComponentType<ECS_TYPE, UnknownComponents<ECS_TYPE>> var3
   ) {
      var1.validateComponents(var2, var3);
      long var4 = this.lock.writeLock();

      try {
         this.archetype = var1;
         this.components = var2;
         this.ensureValidComponents = false;
      } class="kw">finally {
         this.lock.unlockWrite(var4);
      }
   }

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

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void ensureComponent(@Nonnull ComponentType<ECS_TYPE, T> var1) {
      assert this.archetype != null;
      assert this.registry != null;
      if (this.ensureValidComponents) {
         var1.validate();
      }

      long var2 = this.lock.writeLock();

      try {
         if (!this.archetype.contains(var1)) {
            Component var4 = this.registry.createComponent(var1);
            this.addComponent0(var1, var4);
            class="kw">return;
         }
      } class="kw">finally {
         this.lock.unlockWrite(var2);
      }
   }

   @Nonnull
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T ensureAndGetComponent(@Nonnull ComponentType<ECS_TYPE, T> var1) {
      assert this.archetype != null;
      assert this.registry != null;
      if (this.ensureValidComponents) {
         var1.validate();
      }

      long var2 = this.lock.writeLock();

      try {
         if (!this.archetype.contains(var1)) {
            Component var4 = this.registry.createComponent(var1);
            this.addComponent0(var1, var4);
            class="kw">return var4;
         } else {
            class="kw">return (T)this.components[var1.getIndex()];
         }
      } class="kw">finally {
         this.lock.unlockWrite(var2);
      }
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void addComponent(@Nonnull ComponentType<ECS_TYPE, T> var1, @Nonnull T var2) {
      assert this.archetype != null;
      if (!this.addComponentInternal(var1, var2)) {
         throw new IllegalArgumentException("Entity contains component type: " + var1);
      }
   }

   <T class="kw">extends Component<ECS_TYPE>> boolean addComponentInternal(@Nonnull ComponentType<ECS_TYPE, T> var1, @Nonnull T var2) {
      assert this.archetype != null;
      long var3 = this.lock.writeLock();

      try {
         if (this.ensureValidComponents) {
            var1.validate();
         }

         if (this.archetype.contains(var1)) {
            class="kw">return false;
         }

         this.addComponent0(var1, var2);
         class="kw">return true;
      } class="kw">finally {
         this.lock.unlockWrite(var3);
      }
   }

   class="kw">private <T class="kw">extends Component<ECS_TYPE>> void addComponent0(@Nonnull ComponentType<ECS_TYPE, T> var1, @Nonnull T var2) {
      assert this.archetype != null;
      assert this.components != null;
      this.archetype = Archetype.add(this.archetype, var1);
      int var3 = this.archetype.length();
      if (this.components.length < var3) {
         this.components = Arrays.copyOf(this.components, var3);
      }

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

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void replaceComponent(@Nonnull ComponentType<ECS_TYPE, T> var1, @Nonnull T var2) {
      assert this.archetype != null;
      assert this.components != null;
      long var3 = this.lock.writeLock();

      try {
         if (this.ensureValidComponents) {
            var1.validate();
         }

         this.archetype.validateComponentType(var1);
         this.components[var1.getIndex()] = var2;
      } class="kw">finally {
         this.lock.unlockWrite(var3);
      }
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void putComponent(@Nonnull ComponentType<ECS_TYPE, T> var1, @Nonnull T var2) {
      assert this.archetype != null;
      assert this.components != null;
      if (this.ensureValidComponents) {
         var1.validate();
      }

      long var3 = this.lock.writeLock();

      try {
         if (this.archetype.contains(var1)) {
            this.archetype.validateComponentType(var1);
            this.components[var1.getIndex()] = var2;
         } else {
            this.addComponent0(var1, var2);
         }
      } class="kw">finally {
         this.lock.unlockWrite(var3);
      }
   }

   @Nullable
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T getComponent(@Nonnull ComponentType<ECS_TYPE, T> var1) {
      assert this.archetype != null;
      assert this.components != null;
      long var2 = this.lock.readLock();

      try {
         if (this.ensureValidComponents) {
            var1.validate();
         }

         class="kw">return (T)(!this.archetype.contains(var1) ? null : this.components[var1.getIndex()]);
      } class="kw">finally {
         this.lock.unlockRead(var2);
      }
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void removeComponent(@Nonnull ComponentType<ECS_TYPE, T> var1) {
      assert this.archetype != null;
      assert this.components != null;
      long var2 = this.lock.writeLock();

      try {
         if (this.ensureValidComponents) {
            var1.validate();
         }

         this.archetype.validateComponentType(var1);
         this.archetype = Archetype.remove(this.archetype, var1);
         this.components[var1.getIndex()] = null;
      } class="kw">finally {
         this.lock.unlockWrite(var2);
      }
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> boolean tryRemoveComponent(@Nonnull ComponentType<ECS_TYPE, T> var1) {
      assert this.archetype != null;
      assert this.components != null;
      if (this.ensureValidComponents) {
         var1.validate();
      }

      long var2 = this.lock.writeLock();

      try {
         if (!this.archetype.contains(var1)) {
            class="kw">return false;
         }

         this.archetype.validateComponentType(var1);
         this.archetype = Archetype.remove(this.archetype, var1);
         this.components[var1.getIndex()] = null;
         class="kw">return true;
      } class="kw">finally {
         this.lock.unlockWrite(var2);
      }
   }

   class="kw">public boolean hasSerializableComponents(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
      assert this.archetype != null;
      class="kw">return this.archetype.hasSerializableComponents(var1);
   }

   class="kw">public void updateData(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nonnull ComponentRegistry.Data<ECS_TYPE> var2) {
      assert this.archetype != null;
      assert this.components != null;
      assert this.registry != null;
      long var3 = this.lock.writeLock();

      try {
         if (this.archetype.isEmpty()) {
            class="kw">return;
         }

         ComponentType var5 = this.registry.getUnknownComponentType();

         for (int var6 = 0; var6 < var2.getDataChangeCount(); var6++) {
            if (var2.getDataChange(var6) class="kw">instanceof ComponentChange var8) {
               ComponentType var9 = var8.getComponentType();
               class="kw">switch (var8.getType()) {
                  case REGISTERED:
                     assert this.archetype != null;
                     if (!this.archetype.contains(var9) && this.archetype.contains(var5)) {
                        String var17 = var2.getComponentId(var9);
                        Codec var18 = var2.getComponentCodec((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var9);
                        if (var18 != null) {
                           UnknownComponents var19 = (UnknownComponents<ECS_TYPE>)this.components[var5.getIndex()];
                           assert var19 != null;
                           Component var20 = var19.removeComponent(var17, var18);
                           if (var20 != null) {
                              this.addComponent0(var9, var20);
                           }
                        }
                     }
                     break;
                  case UNREGISTERED:
                     assert this.archetype != null;
                     if (this.archetype.contains(var9)) {
                        String var10 = var1.getComponentId(var9);
                        Codec var11 = var1.getComponentCodec((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var9);
                        if (var11 != null) {
                           UnknownComponents var12;
                           if (this.archetype.contains(var5)) {
                              var12 = (UnknownComponents<ECS_TYPE>)this.components[var5.getIndex()];
                              assert var12 != null;
                           } else {
                              var12 = new UnknownComponents<>();
                              this.addComponent0(var5, var12);
                           }

                           Component var13 = this.components[var9.getIndex()];
                           var12.addComponent(var10, var13, var11);
                        }

                        this.archetype = Archetype.remove(this.archetype, var9);
                        this.components[var9.getIndex()] = null;
                     }
               }
            }
         }
      } class="kw">finally {
         this.lock.unlockWrite(var3);
      }
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> clone() {
      assert this.archetype != null;
      assert this.components != null;
      assert this.registry != null;
      long var1 = this.lock.readLock();

      try {
         Component[] var3 = new Component[this.components.length];

         for (int var4 = 0; var4 < this.components.length; var4++) {
            Component var5 = this.components[var4];
            if (var5 != null) {
               var3[var4] = var5.clone();
            }
         }

         class="kw">return this.registry.newHolder(this.archetype, var3);
      } class="kw">finally {
         this.lock.unlockRead(var1);
      }
   }

   class="kw">public Holder<ECS_TYPE> cloneSerializable(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
      class="kw">return this.cloneSerializable(var1, null);
   }

   class="kw">public Holder<ECS_TYPE> cloneSerializable(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nullable Predicate<ComponentType<ECS_TYPE, ?>> var2) {
      assert this.archetype != null;
      assert this.components != null;
      assert this.registry != null;
      long var3 = this.lock.readLock();

      try {
         Archetype var5 = this.archetype.getSerializableArchetype(var1, var2);
         Component[] var6 = new Component[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) {
               var6[var7] = this.components[var7].cloneSerializable();
            }
         }

         class="kw">return this.registry.newHolder(var5, var6);
      } class="kw">finally {
         this.lock.unlockRead(var3);
      }
   }

   void loadComponentsMap(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nonnull Map<String, Component<ECS_TYPE>> var2) {
      assert this.components != null;
      long var3 = this.lock.writeLock();

      try {
         ComponentType[] var5 = new ComponentType[var2.size()];
         int var6 = 0;
         ComponentType var7 = var1.getRegistry().getUnknownComponentType();
         UnknownComponents var8 = (UnknownComponents<ECS_TYPE>)var2.remove("Unknown");
         if (var8 != null) {
            for (Entry var10 : var8.getUnknownComponents().entrySet()) {
               ComponentType var11 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)var1.getComponentType(var10.getKey());
               if (var11 != null && !var2.containsKey(var10.getKey())) {
                  Codec var12 = var1.getComponentCodec((ComponentType<ECS_TYPE, Component<ECS_TYPE>>)var11);
                  ExtraInfo var13 = ExtraInfo.THREAD_LOCAL.get();
                  Component var14 = var12.decode((BsonValue)var10.getValue(), var13);
                  var13.getValidationResults().logOrThrowValidatorExceptions(UnknownComponents.LOGGER);
                  if (var5.length <= var6) {
                     var5 = Arrays.copyOf(var5, var6 + 1);
                  }

                  var5[var6++] = var11;
                  int var15 = var11.getIndex();
                  if (this.components.length <= var15) {
                     this.components = Arrays.copyOf(this.components, var15 + 1);
                  }

                  this.components[var15] = var14;
               }
            }

            if (var5.length <= var6) {
               var5 = Arrays.copyOf(var5, var6 + 1);
            }

            var5[var6++] = var7;
            int var19 = var7.getIndex();
            if (this.components.length <= var19) {
               this.components = Arrays.copyOf(this.components, var19 + 1);
            }

            this.components[var19] = var8;
         }

         for (Entry var21 : var2.entrySet()) {
            Component var22 = var21.getValue();
            if (var22 class="kw">instanceof TempUnknownComponent var23) {
               if (var8 == null) {
                  var8 = new UnknownComponents<>();
                  if (var5.length <= var6) {
                     var5 = Arrays.copyOf(var5, var6 + 1);
                  }

                  var5[var6++] = var7;
                  int var25 = var7.getIndex();
                  if (this.components.length <= var25) {
                     this.components = Arrays.copyOf(this.components, var25 + 1);
                  }

                  this.components[var25] = var8;
               }

               var8.addComponent(var21.getKey(), var23);
            } else {
               ComponentType var24 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)var1.getComponentType(var21.getKey());
               if (var5.length <= var6) {
                  var5 = Arrays.copyOf(var5, var6 + 1);
               }

               var5[var6++] = var24;
               int var26 = var24.getIndex();
               if (this.components.length <= var26) {
                  this.components = Arrays.copyOf(this.components, var26 + 1);
               }

               this.components[var26] = var22;
            }
         }

         this.archetype = Archetype.of(var5.length == var6 ? var5 : Arrays.copyOf(var5, var6));
      } class="kw">finally {
         this.lock.unlockWrite(var3);
      }
   }

   @Nonnull
   Map<String, Component<ECS_TYPE>> createComponentsMap(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
      assert this.archetype != null;
      assert this.components != null;
      long var2 = this.lock.readLock();

      try {
         if (this.archetype.isEmpty()) {
            class="kw">return Collections.emptyMap();
         }

         ComponentRegistry var4 = var1.getRegistry();
         ComponentType var5 = var4.getUnknownComponentType();
         Map var6 = new Object2ObjectOpenHashMap(this.archetype.length());

         for (int var7 = this.archetype.getMinIndex(); var7 < this.archetype.length(); var7++) {
            ComponentType var8 = (ComponentType<ECS_TYPE, ? class="kw">extends Component<ECS_TYPE>>)this.archetype.get(var7);
            if (var8 != null && var1.getComponentCodec(var8) != null) {
               if (var8.equals(var5)) {
                  UnknownComponents var9 = (UnknownComponents<ECS_TYPE>)this.components[var8.getIndex()];

                  for (Entry var11 : var9.getUnknownComponents().entrySet()) {
                     var6.putIfAbsent(var11.getKey(), new TempUnknownComponent<>(var11.getValue()));
                  }
               } else {
                  var6.put(var1.getComponentId(var8), this.components[var8.getIndex()]);
               }
            }
         }

         class="kw">return var6;
      } class="kw">finally {
         this.lock.unlockRead(var2);
      }
   }

   @Override
   class="kw">public boolean equals(@Nullable Object var1) {
      if (this == var1) {
         class="kw">return true;
      }

      if (var1 != null && this.getClass() == var1.getClass()) {
         Holder var2 = (Holder<?>)var1;
         long var3 = this.lock.readLock();
         long var5 = var2.lock.readLock();

         try {
            class="kw">return !Objects.equals(this.archetype, var2.archetype) ? false : Arrays.equals(this.components, var2.components);
         } class="kw">finally {
            var2.lock.unlockRead(var5);
            this.lock.unlockRead(var3);
         }
      } else {
         class="kw">return false;
      }
   }

   @Override
   class="kw">public int hashCode() {
      long var1 = this.lock.readLock();

      try {
         int var3 = this.archetype != null ? this.archetype.hashCode() : 0;
         class="kw">return 31 * var3 + Arrays.hashCode(this.components);
      } class="kw">finally {
         this.lock.unlockRead(var1);
      }
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      long var1 = this.lock.readLock();

      try {
         class="kw">return "Holder{archetype=" + this.archetype + ", components=" + Arrays.toString(this.components) + "}";
      } class="kw">finally {
         this.lock.unlockRead(var1);
      }
   }
}