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

class="kw">import com.hypixel.hytale.common.util.DebugFlags;
class="kw">import com.hypixel.hytale.component.event.EntityEventType;
class="kw">import com.hypixel.hytale.component.event.EntityHolderEventType;
class="kw">import com.hypixel.hytale.component.event.WorldEventType;
class="kw">import com.hypixel.hytale.component.system.EcsEvent;
class="kw">import java.util.ArrayDeque;
class="kw">import java.util.Deque;
class="kw">import java.util.function.Consumer;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class CommandBuffer<ECS_TYPE> class="kw">implements ComponentAccessor<ECS_TYPE> {
   @Nonnull
   class="kw">private class="kw">final Store<ECS_TYPE> store;
   @Nonnull
   class="kw">private class="kw">final Deque<Consumer<Store<ECS_TYPE>>> queue = new ArrayDeque<>();
   @Nullable
   class="kw">private Ref<ECS_TYPE> trackedRef;
   class="kw">private boolean trackedRefRemoved;
   @Nullable
   class="kw">private CommandBuffer<ECS_TYPE> parentBuffer;
   @Nullable
   class="kw">private Thread thread;

   class="kw">protected CommandBuffer(@Nonnull Store<ECS_TYPE> var1) {
      this.store = var1;
      assert this.setThread();
   }

   @Nonnull
   class="kw">public Store<ECS_TYPE> getStore() {
      class="kw">return this.store;
   }

   class="kw">public void run(@Nonnull Consumer<Store<ECS_TYPE>> var1) {
      assert Thread.currentThread() == this.thread;
      this.queue.add(var1);
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T getComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      assert Thread.currentThread() == this.thread;
      class="kw">return this.store.__internal_getComponent(var1, var2);
   }

   @Nonnull
   @Override
   class="kw">public Archetype<ECS_TYPE> getArchetype(@Nonnull Ref<ECS_TYPE> var1) {
      assert Thread.currentThread() == this.thread;
      class="kw">return this.store.__internal_getArchetype(var1);
   }

   @Nonnull
   @Override
   class="kw">public <T class="kw">extends Resource<ECS_TYPE>> T getResource(@Nonnull ResourceType<ECS_TYPE, T> var1) {
      assert Thread.currentThread() == this.thread;
      class="kw">return this.store.__internal_getResource(var1);
   }

   @Nonnull
   @Override
   class="kw">public ECS_TYPE getExternalData() {
      class="kw">return this.store.getExternalData();
   }

   @Nonnull
   @Override
   class="kw">public Ref<ECS_TYPE>[] addEntities(@Nonnull Holder<ECS_TYPE>[] var1, @Nonnull AddReason var2) {
      assert Thread.currentThread() == this.thread;
      Ref[] var3 = new Ref[var1.length];

      for (int var4 = 0; var4 < var1.length; var4++) {
         var3[var4] = new Ref<>(this.store);
      }

      this.queue.add(var3x -> var3x.addEntities(var1, var3, var2));
      class="kw">return var3;
   }

   @Nonnull
   @Override
   class="kw">public Ref<ECS_TYPE> addEntity(@Nonnull Holder<ECS_TYPE> var1, @Nonnull AddReason var2) {
      assert Thread.currentThread() == this.thread;
      Ref var3 = new Ref<>(this.store);
      this.queue.add(var3x -> var3x.addEntity(var1, var3, var2));
      class="kw">return var3;
   }

   class="kw">public void addEntities(@Nonnull Holder<ECS_TYPE>[] var1, int var2, @Nonnull Ref<ECS_TYPE>[] var3, int var4, int var5, @Nonnull AddReason var6) {
      assert Thread.currentThread() == this.thread;

      for (int var7 = var4; var7 < var4 + var5; var7++) {
         var3[var7] = new Ref<>(this.store);
      }

      this.queue.add(var6x -> var6x.addEntities(var1, var2, var3, var4, var5, var6));
   }

   @Nonnull
   class="kw">public Ref<ECS_TYPE> addEntity(@Nonnull Holder<ECS_TYPE> var1, @Nonnull Ref<ECS_TYPE> var2, @Nonnull AddReason var3) {
      if (var2.isValid()) {
         throw new IllegalArgumentException("EntityReference is already in use!");
      }

      if (var2.getStore() != this.store) {
         throw new IllegalArgumentException("EntityReference is not for the correct store!");
      }

      assert Thread.currentThread() == this.thread;
      this.queue.add(var3x -> var3x.addEntity(var1, var2, var3));
      class="kw">return var2;
   }

   @Nonnull
   class="kw">public Holder<ECS_TYPE> copyEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2) {
      assert Thread.currentThread() == this.thread;
      this.queue.add(var2x -> var2x.copyEntity(var1, var2));
      class="kw">return var2;
   }

   class="kw">public void tryRemoveEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull RemoveReason var2) {
      assert Thread.currentThread() == this.thread;
      Throwable var3 = DebugFlags.CAPTURE_THROWABLES ? new Throwable() : null;
      this.queue.add(var3x -> {
         if (var1.isValid()) {
            var3x.removeEntity(var1, var3x.getRegistry().newHolder(), var2, var3);
         }
      });
      if (var1.equals(this.trackedRef)) {
         this.trackedRefRemoved = true;
      }

      if (this.parentBuffer != null) {
         this.parentBuffer.testRemovedTracked(var1);
      }
   }

   class="kw">public void removeEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull RemoveReason var2) {
      assert Thread.currentThread() == this.thread;
      Throwable var3 = DebugFlags.CAPTURE_THROWABLES ? new Throwable() : null;
      this.queue.add(var3x -> var3x.removeEntity(var1, var3x.getRegistry().newHolder(), var2, var3));
      if (var1.equals(this.trackedRef)) {
         this.trackedRefRemoved = true;
      }

      if (this.parentBuffer != null) {
         this.parentBuffer.testRemovedTracked(var1);
      }
   }

   @Nonnull
   @Override
   class="kw">public Holder<ECS_TYPE> removeEntity(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Holder<ECS_TYPE> var2, @Nonnull RemoveReason var3) {
      assert Thread.currentThread() == this.thread;
      Throwable var4 = DebugFlags.CAPTURE_THROWABLES ? new Throwable() : null;
      this.queue.add(var4x -> var4x.removeEntity(var1, var2, var3, var4));
      if (var1.equals(this.trackedRef)) {
         this.trackedRefRemoved = true;
      }

      if (this.parentBuffer != null) {
         this.parentBuffer.testRemovedTracked(var1);
      }

      class="kw">return var2;
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void ensureComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      assert Thread.currentThread() == this.thread;
      this.queue.add(var2x -> {
         if (var1.isValid()) {
            var2x.ensureComponent(var1, var2);
         }
      });
   }

   @Nonnull
   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T ensureAndGetComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      assert Thread.currentThread() == this.thread;
      Component var3 = this.store.__internal_getComponent(var1, var2);
      if (var3 != null) {
         class="kw">return var3;
      }

      Component var4 = this.store.getRegistry()._internal_getData().createComponent(var2);
      this.queue.add(var3x -> {
         if (var1.isValid()) {
            var3x.addComponent(var1, var2, var4);
         }
      });
      class="kw">return var4;
   }

   @Nonnull
   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> T addComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      assert Thread.currentThread() == this.thread;
      Component var3 = this.store.getRegistry()._internal_getData().createComponent(var2);
      this.queue.add(var3x -> {
         if (var1.isValid()) {
            var3x.addComponent(var1, var2, var3);
         }
      });
      class="kw">return var3;
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void addComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
      assert Thread.currentThread() == this.thread;
      this.queue.add(var3x -> {
         if (var1.isValid()) {
            var3x.addComponent(var1, var2, var3);
         }
      });
   }

   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void replaceComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
      assert Thread.currentThread() == this.thread;
      this.queue.add(var3x -> {
         if (var1.isValid()) {
            var3x.replaceComponent(var1, var2, var3);
         }
      });
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void removeComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      assert Thread.currentThread() == this.thread;
      this.queue.add(var2x -> {
         if (var1.isValid()) {
            var2x.removeComponent(var1, var2);
         }
      });
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void tryRemoveComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2) {
      assert Thread.currentThread() == this.thread;
      this.queue.add(var2x -> {
         if (var1.isValid()) {
            var2x.tryRemoveComponent(var1, var2);
         }
      });
   }

   @Override
   class="kw">public <T class="kw">extends Component<ECS_TYPE>> void putComponent(@Nonnull Ref<ECS_TYPE> var1, @Nonnull ComponentType<ECS_TYPE, T> var2, @Nonnull T var3) {
      assert Thread.currentThread() == this.thread;
      this.queue.add(var3x -> {
         if (var1.isValid()) {
            var3x.putComponent(var1, var2, var3);
         }
      });
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Ref<ECS_TYPE> var1, @Nonnull Event var2) {
      assert Thread.currentThread() == this.thread;
      this.store.internal_invoke(this, var1, var2);
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull EntityEventType<ECS_TYPE, Event> var1, @Nonnull Ref<ECS_TYPE> var2, @Nonnull Event var3) {
      assert Thread.currentThread() == this.thread;
      this.store.internal_invoke(this, var1, var2, var3);
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Holder<ECS_TYPE> var1, @Nonnull Event var2) {
      assert Thread.currentThread() == this.thread;
      this.store.internal_invoke(this, var1, var2);
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull EntityHolderEventType<ECS_TYPE, Event> var1, @Nonnull Holder<ECS_TYPE> var2, @Nonnull Event var3) {
      assert Thread.currentThread() == this.thread;
      this.store.internal_invoke(this, var1, var2, var3);
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull Event var1) {
      assert Thread.currentThread() == this.thread;
      this.store.internal_invoke(this, var1);
   }

   @Override
   class="kw">public <Event class="kw">extends EcsEvent> void invoke(@Nonnull WorldEventType<ECS_TYPE, Event> var1, @Nonnull Event var2) {
      assert Thread.currentThread() == this.thread;
      this.store.internal_invoke(this, var1, var2);
   }

   void track(@Nonnull Ref<ECS_TYPE> var1) {
      this.trackedRef = var1;
   }

   class="kw">private void testRemovedTracked(@Nonnull Ref<ECS_TYPE> var1) {
      if (var1.equals(this.trackedRef)) {
         this.trackedRefRemoved = true;
      }

      if (this.parentBuffer != null) {
         this.parentBuffer.testRemovedTracked(var1);
      }
   }

   boolean consumeWasTrackedRefRemoved() {
      if (this.trackedRef == null) {
         throw new IllegalStateException("Not tracking any ref!");
      }

      boolean var1 = this.trackedRefRemoved;
      this.trackedRefRemoved = false;
      class="kw">return var1;
   }

   void consume() {
      this.trackedRef = null;
      this.trackedRefRemoved = false;
      assert Thread.currentThread() == this.thread;

      while (!this.queue.isEmpty()) {
         this.queue.pop().accept(this.store);
      }

      this.store.storeCommandBuffer(this);
   }

   @Nonnull
   class="kw">public CommandBuffer<ECS_TYPE> fork() {
      CommandBuffer var1 = this.store.takeCommandBuffer();
      var1.parentBuffer = this;
      class="kw">return var1;
   }

   class="kw">public void mergeParallel(@Nonnull CommandBuffer<ECS_TYPE> var1) {
      this.trackedRef = null;
      this.trackedRefRemoved = false;
      this.parentBuffer = null;

      while (!this.queue.isEmpty()) {
         var1.queue.add(this.queue.pop());
      }

      this.store.storeCommandBuffer(this);
   }

   class="kw">public boolean setThread() {
      boolean var1;
      assert var1 = true;
      if (!var1) {
         throw new AssertionError("setThread should only be called when assertions are enabled!");
      }

      this.thread = Thread.currentThread();
      class="kw">return true;
   }

   class="kw">public void validateEmpty() {
      if (!this.queue.isEmpty()) {
         throw new AssertionError("CommandBuffer must be empty when returned to store!");
      }
   }
}