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

class="kw">import com.hypixel.hytale.component.data.unknown.UnknownComponents;
class="kw">import com.hypixel.hytale.component.query.ExactArchetypeQuery;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import java.util.Arrays;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class Archetype<ECS_TYPE> class="kw">implements Query<ECS_TYPE> {
   @Nonnull
   class="kw">private class="kw">static class="kw">final Archetype EMPTY = new Archetype(0, 0, ComponentType.EMPTY_ARRAY);
   class="kw">private class="kw">final int minIndex;
   class="kw">private class="kw">final int count;
   @Nonnull
   class="kw">private class="kw">final ComponentType<ECS_TYPE, ?>[] componentTypes;
   @Nullable
   class="kw">private ExactArchetypeQuery<ECS_TYPE> exactQuery;
   class="kw">private class="kw">final int hashCode;

   class="kw">public class="kw">static <ECS_TYPE> Archetype<ECS_TYPE> empty() {
      class="kw">return EMPTY;
   }

   class="kw">private Archetype(int var1, int var2, @Nonnull ComponentType<ECS_TYPE, ?>[] var3) {
      this.minIndex = var1;
      this.count = var2;
      this.componentTypes = var3;
      this.hashCode = Arrays.hashCode(var3);
   }

   class="kw">public int getMinIndex() {
      class="kw">return this.minIndex;
   }

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

   class="kw">public int length() {
      class="kw">return this.componentTypes.length;
   }

   @Nullable
   class="kw">public ComponentType<ECS_TYPE, ?> get(int var1) {
      class="kw">return this.componentTypes[var1];
   }

   class="kw">public boolean isEmpty() {
      class="kw">return this.componentTypes.length == 0;
   }

   class="kw">public boolean contains(@Nonnull ComponentType<ECS_TYPE, ?> var1) {
      class="kw">return this.containsAt(var1.getIndex(), var1);
   }

   boolean containsAt(int var1, @Nonnull ComponentType<ECS_TYPE, ?> var2) {
      class="kw">return var1 < this.componentTypes.length && this.componentTypes[var1] == var2;
   }

   class="kw">public boolean contains(@Nonnull Archetype<ECS_TYPE> var1) {
      if (this != var1 && !var1.isEmpty()) {
         for (int var2 = var1.minIndex; var2 < var1.componentTypes.length; var2++) {
            ComponentType var3 = var1.componentTypes[var2];
            if (var3 != null && !this.contains(var3)) {
               class="kw">return false;
            }
         }

         class="kw">return true;
      } else {
         class="kw">return true;
      }
   }

   class="kw">public void validateComponentType(@Nonnull ComponentType<ECS_TYPE, ?> var1) {
      if (!this.contains(var1)) {
         throw new IllegalArgumentException("ComponentType is not in archetype: " + var1 + ", " + this);
      }
   }

   class="kw">public void validateComponents(@Nonnull Component<ECS_TYPE>[] var1, @Nullable ComponentType<ECS_TYPE, UnknownComponents<ECS_TYPE>> var2) {
      int var3 = Math.max(this.componentTypes.length, var1.length);

      for (int var4 = 0; var4 < var3; var4++) {
         ComponentType var5 = var4 >= this.componentTypes.length ? null : this.componentTypes[var4];
         Component var6 = var4 >= var1.length ? null : var1[var4];
         if (var5 == null) {
            if (var6 != null && (var2 == null || var4 != var2.getIndex())) {
               throw new IllegalStateException("Invalid component at index " + var4 + " expected null but found " + var6.getClass());
            }
         } else {
            Class var7 = var5.getTypeClass();
            if (var6 == null) {
               throw new IllegalStateException("Invalid component at index " + var4 + " expected " + var7 + " but found null");
            }

            Class var8 = (Class<? class="kw">extends Component>)var6.getClass();
            if (!var8.equals(var7)) {
               throw new IllegalStateException("Invalid component at index " + var4 + " expected " + var7 + " but found " + var8);
            }
         }
      }
   }

   class="kw">public boolean hasSerializableComponents(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1) {
      if (this.isEmpty()) {
         class="kw">return false;
      }

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

      for (int var2 = this.minIndex; var2 < this.componentTypes.length; var2++) {
         ComponentType var3 = this.componentTypes[var2];
         if (var3 != null && var1.getComponentCodec(var3) != null) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   @Nonnull
   class="kw">public Archetype<ECS_TYPE> getSerializableArchetype(@Nonnull ComponentRegistry.Data<ECS_TYPE> var1, @Nullable Predicate<ComponentType<ECS_TYPE, ?>> var2) {
      if (this.isEmpty()) {
         class="kw">return EMPTY;
      }

      if (this.contains(var1.getRegistry().getNonSerializedComponentType())) {
         class="kw">return EMPTY;
      }

      ComponentType[] var3 = null;
      int var4 = 0;

      for (int var5 = this.componentTypes.length - 1; var5 >= this.minIndex; var5--) {
         ComponentType var6 = this.componentTypes[var5];
         if (var6 != null && var1.getComponentCodec(var6) != null && (var2 == null || var2.test(var6))) {
            if (var3 == null) {
               var3 = new ComponentType[var5 + 1];
            }

            var3[var5] = var6;
            var4++;
         }
      }

      class="kw">return var3 == null ? EMPTY : new Archetype<>(this.minIndex, var4, var3);
   }

   @Nonnull
   class="kw">public ExactArchetypeQuery<ECS_TYPE> asExactQuery() {
      if (this.exactQuery == null) {
         this.exactQuery = new ExactArchetypeQuery<>(this);
      }

      class="kw">return this.exactQuery;
   }

   @Nonnull
   class="kw">public class="kw">static <ECS_TYPE> Archetype<ECS_TYPE> of(@Nonnull ComponentType<ECS_TYPE, ?> var0) {
      if (var0 == null) {
         throw new IllegalArgumentException("ComponentType in Archetype cannot be null");
      }

      int var1 = var0.getIndex();
      ComponentType[] var2 = new ComponentType[var1 + 1];
      var2[var1] = var0;
      class="kw">return new Archetype<>(var1, 1, var2);
   }

   @SafeVarargs
   class="kw">public class="kw">static <ECS_TYPE> Archetype<ECS_TYPE> of(@Nonnull ComponentType<ECS_TYPE, ?>... var0) {
      int var1 = var0.length;
      if (var1 == 0) {
         class="kw">return EMPTY;
      }

      ComponentRegistry var2 = var0[0].getRegistry();
      int var3 = Integer.MAX_VALUE;
      int var4 = Integer.MIN_VALUE;

      for (int var5 = 0; var5 < var1; var5++) {
         ComponentType var6 = var0[var5];
         if (var6 == null) {
            throw new IllegalArgumentException("ComponentType in Archetype cannot be null (Index: " + var5 + ")");
         }

         var6.validateRegistry(var2);
         int var7 = var6.getIndex();
         if (var7 < var3) {
            var3 = var7;
         }

         if (var7 > var4) {
            var4 = var7;
         }
      }

      ComponentType[] var11 = new ComponentType[var4 + 1];

      for (ComponentType var9 : var0) {
         int var10 = var9.getIndex();
         if (var11[var10] != null) {
            throw new IllegalArgumentException("ComponentType provided multiple times! " + Arrays.toString(var0));
         }

         var11[var10] = var9;
      }

      class="kw">return new Archetype<>(var3, var1, var11);
   }

   @Nonnull
   class="kw">public class="kw">static <ECS_TYPE, T class="kw">extends Component<ECS_TYPE>> Archetype<ECS_TYPE> add(@Nonnull Archetype<ECS_TYPE> var0, @Nonnull ComponentType<ECS_TYPE, T> var1) {
      if (var0.isEmpty()) {
         class="kw">return of(var1);
      }

      if (var0.contains(var1)) {
         throw new IllegalArgumentException("ComponentType is already in Archetype! " + var0 + ", " + var1);
      }

      var0.validateRegistry(var1.getRegistry());
      int var2 = var1.getIndex();
      int var3 = Math.min(var2, var0.minIndex);
      int var4 = Math.max(var2 + 1, var0.componentTypes.length);
      ComponentType[] var5 = Arrays.copyOf(var0.componentTypes, var4);
      var5[var2] = var1;
      class="kw">return new Archetype<>(var3, var0.count + 1, var5);
   }

   class="kw">public class="kw">static <ECS_TYPE, T class="kw">extends Component<ECS_TYPE>> Archetype<ECS_TYPE> remove(
      @Nonnull Archetype<ECS_TYPE> var0, @Nonnull ComponentType<ECS_TYPE, T> var1
   ) {
      if (var0.isEmpty()) {
         throw new IllegalArgumentException("Archetype is already empty!");
      }

      if (!var0.contains(var1)) {
         throw new IllegalArgumentException("Archetype doesn't contain ComponentType! " + var0 + ", " + var1);
      }

      int var2 = var0.componentTypes.length;
      int var3 = var0.minIndex;
      int var4 = var2 - 1;
      if (var3 == var4) {
         class="kw">return EMPTY;
      }

      int var5 = var0.count - 1;
      int var6 = var1.getIndex();
      if (var6 == var4) {
         int var9 = var6 - 1;

         while (var9 > var3 && var0.componentTypes[var9] == null) {
            var9--;
         }

         class="kw">return new Archetype<>(var3, var5, Arrays.copyOf(var0.componentTypes, var9 + 1));
      } else {
         ComponentType[] var7 = Arrays.copyOf(var0.componentTypes, var2);
         var7[var6] = null;
         if (var6 != var3) {
            class="kw">return new Archetype<>(var3, var5, var7);
         }

         int var8 = var6 + 1;

         while (var8 < var2 && var7[var8] == null) {
            var8++;
         }

         class="kw">return new Archetype<>(var8, var5, var7);
      }
   }

   @Override
   class="kw">public boolean test(@Nonnull Archetype<ECS_TYPE> var1) {
      class="kw">return var1.contains(this);
   }

   @Override
   class="kw">public boolean requiresComponentType(@Nonnull ComponentType<ECS_TYPE, ?> var1) {
      class="kw">return this.contains(var1);
   }

   @Override
   class="kw">public void validateRegistry(@Nonnull ComponentRegistry<ECS_TYPE> var1) {
      if (!this.isEmpty()) {
         this.componentTypes[this.minIndex].validateRegistry(var1);
      }
   }

   @Override
   class="kw">public void validate() {
      for (int var1 = this.minIndex; var1 < this.componentTypes.length; var1++) {
         ComponentType var2 = this.componentTypes[var1];
         if (var2 != null) {
            var2.validate();
         }
      }
   }

   @Override
   class="kw">public boolean equals(@Nullable Object var1) {
      if (this == var1) {
         class="kw">return true;
      } else if (var1 != null && this.getClass() == var1.getClass()) {
         Archetype var2 = (Archetype<?>)var1;
         class="kw">return Arrays.equals(this.componentTypes, var2.componentTypes);
      } else {
         class="kw">return false;
      }
   }

   @Override
   class="kw">public int hashCode() {
      class="kw">return this.hashCode;
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "Archetype{componentTypes=" + Arrays.toString(this.componentTypes) + "}";
   }
}