class="kw">package com.hypixel.hytale.builtin.triggervolumes.system;

class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.SignalTag;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerContext;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerEffect;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.effect.TriggerEventType;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.TriggerVolumeManager;
class="kw">import com.hypixel.hytale.builtin.triggervolumes.manager.VolumeEntry;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.PriorityQueue;
class="kw">import java.util.UUID;
class="kw">import java.util.function.Predicate;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class DelayedEffectScheduler {
   @Nonnull
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">private class="kw">final PriorityQueue<DelayedEffectScheduler.ScheduledItem> queue = new PriorityQueue<>();

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

   class="kw">public void schedule(
      @Nonnull TriggerEffect var1,
      @Nullable Ref<EntityStore> var2,
      @Nonnull UUID var3,
      @Nonnull TriggerEventType var4,
      @Nonnull VolumeEntry var5,
      long var6,
      float var8,
      @Nullable List<VolumeEntry> var9,
      @Nullable DelayedEffectScheduler.ScheduledEffectCallback var10,
      @Nonnull Store<EntityStore> var11,
      @Nullable TriggerVolumeManager.PendingTriggerEvent var12
   ) {
      long var13 = var6 + (long)(var8 * 1.0E9F);
      Ref var15 = var5.getProjectileSource().resolveActorRef(var2, var11);
      Vector3d var16 = captureActorPosition(var15, var11);
      List var17 = var12 != null ? var12.signalTags() : List.of();
      Vector3d var18 = var12 != null ? var12.blockPosition() : null;
      String var19 = var12 != null ? var12.blockId() : null;
      InteractionType var20 = var12 != null ? var12.interactionType() : null;
      this.queue.add(new DelayedEffectScheduler.ScheduledEffect(var13, var1, var2, var15, var16, var3, var4, var5, var9, var17, var18, var19, var20, var10));
   }

   @Nullable
   class="kw">private class="kw">static Vector3d captureActorPosition(@Nullable Ref<EntityStore> var0, @Nonnull Store<EntityStore> var1) {
      if (var0 != null && var0.isValid()) {
         TransformComponent var2 = var1.getComponent(var0, TransformComponent.getComponentType());
         class="kw">return var2 != null ? new Vector3d(var2.getPosition()) : null;
      } else {
         class="kw">return null;
      }
   }

   class="kw">public void scheduleGate(
      @Nonnull DelayedEffectScheduler.ScheduledGateAction var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull UUID var3,
      @Nonnull TriggerEventType var4,
      @Nonnull VolumeEntry var5,
      long var6,
      float var8,
      @Nullable List<VolumeEntry> var9
   ) {
      this.scheduleGate(var1, var2, var3, var4, var5, var6, var8, var9, null);
   }

   class="kw">public void scheduleGate(
      @Nonnull DelayedEffectScheduler.ScheduledGateAction var1,
      @Nonnull Ref<EntityStore> var2,
      @Nonnull UUID var3,
      @Nonnull TriggerEventType var4,
      @Nonnull VolumeEntry var5,
      long var6,
      float var8,
      @Nullable List<VolumeEntry> var9,
      @Nullable Object var10
   ) {
      long var11 = var6 + (long)(var8 * 1.0E9F);
      this.queue.add(new DelayedEffectScheduler.ScheduledGate(var11, var1, var2, var3, var4, var5, var9, var10));
   }

   class="kw">public void tick(long var1, @Nonnull Store<EntityStore> var3) {
      while (!this.queue.isEmpty() && this.queue.peek().executeAtNanos() <= var1) {
         DelayedEffectScheduler.ScheduledItem var4 = this.queue.poll();
         if (var4 != null) {
            boolean var5 = false;

            try {
               if (!var4.volume().isPendingDestroy()) {
                  var5 = var4.execute(var3, var1);
               }
            } catch (Throwable var10) {
               ((HytaleLogger.Api)LOGGER.at(Level.WARNING).withCause(var10))
                  .log("Error executing scheduled trigger item on volume '%s'", var4.volume().getId());
            } class="kw">finally {
               var4.onFinished(var5, var1);
            }
         }
      }
   }

   class="kw">public void cancelForEntity(@Nonnull UUID var1) {
      this.cancelIf(var1x -> var1x.entityUuid().equals(var1));
   }

   class="kw">public void cancelNonExitForEntityInVolume(@Nonnull UUID var1, @Nonnull VolumeEntry var2) {
      this.cancelIf(var2x -> var2x.entityUuid().equals(var1) && var2x.volume() == var2 && var2x.eventType() != TriggerEventType.EXIT);
   }

   class="kw">public void cancelForVolume(@Nonnull VolumeEntry var1) {
      this.cancelIf(var1x -> var1x.volume() == var1);
   }

   class="kw">public void cancelGates(@Nonnull UUID var1, @Nonnull Object var2) {
      this.cancelIf(var2x -> var2x class="kw">instanceof DelayedEffectScheduler.ScheduledGate var3 && var3.entityUuid().equals(var1) && var2.equals(var3.gateKey()));
   }

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

   class="kw">private void cancelIf(@Nonnull Predicate<DelayedEffectScheduler.ScheduledItem> var1) {
      long var2 = System.nanoTime();
      Iterator var4 = this.queue.iterator();

      while (var4.hasNext()) {
         DelayedEffectScheduler.ScheduledItem var5 = var4.next();
         if (var1.test(var5)) {
            var4.remove();
            var5.onFinished(false, var2);
         }
      }
   }

   class="kw">private record ScheduledEffect(
      long executeAtNanos,
      @Nonnull TriggerEffect effect,
      @Nullable Ref<EntityStore> entityRef,
      @Nullable Ref<EntityStore> actorRef,
      @Nullable Vector3d actorPosition,
      @Nonnull UUID entityUuid,
      @Nonnull TriggerEventType eventType,
      @Nonnull VolumeEntry volume,
      @Nullable List<VolumeEntry> spatialVolumes,
      @Nonnull List<SignalTag> signalTags,
      @Nullable Vector3d blockPosition,
      @Nullable String blockId,
      @Nullable InteractionType interactionType,
      @Nullable DelayedEffectScheduler.ScheduledEffectCallback callback
   ) class="kw">implements DelayedEffectScheduler.ScheduledItem {
      class="kw">private ScheduledEffect {
      }

      @Override
      class="kw">public boolean execute(@Nonnull Store<EntityStore> var1, long var2) {
         try {
            List var4 = this.spatialVolumes != null ? this.spatialVolumes : List.of(this.volume);
            TriggerContext var5 = new TriggerContext(
               this.actorRef,
               var1,
               this.eventType,
               this.volume,
               var4,
               this.actorPosition,
               this.signalTags,
               this.blockPosition,
               this.blockId,
               this.interactionType
            );
            this.effect.execute(var5);
            class="kw">return true;
         } catch (Throwable var6) {
            ((HytaleLogger.Api)DelayedEffectScheduler.LOGGER.at(Level.WARNING).withCause(var6))
               .log("Error executing delayed effect %s on volume '%s'", this.effect.getClass().getSimpleName(), this.volume.getId());
            class="kw">return false;
         }
      }

      @Override
      class="kw">public void onFinished(boolean var1, long var2) {
         if (this.callback != null) {
            try {
               this.callback.onFinished(var1, var2);
            } catch (Exception var5) {
               ((HytaleLogger.Api)DelayedEffectScheduler.LOGGER.at(Level.WARNING).withCause(var5))
                  .log("Error finishing delayed effect %s on volume '%s'", this.effect.getClass().getSimpleName(), this.volume.getId());
            }
         }
      }
   }

   class="kw">public class="kw">interface ScheduledEffectCallback {
      void onFinished(boolean var1, long var2);
   }

   class="kw">private record ScheduledGate(
      long executeAtNanos,
      @Nonnull DelayedEffectScheduler.ScheduledGateAction action,
      @Nonnull Ref<EntityStore> entityRef,
      @Nonnull UUID entityUuid,
      @Nonnull TriggerEventType eventType,
      @Nonnull VolumeEntry volume,
      @Nullable List<VolumeEntry> spatialVolumes,
      @Nullable Object gateKey
   ) class="kw">implements DelayedEffectScheduler.ScheduledItem {
      class="kw">private ScheduledGate {
      }

      @Override
      class="kw">public boolean execute(@Nonnull Store<EntityStore> var1, long var2) {
         this.action.execute(this.entityRef, this.entityUuid, this.eventType, this.volume, this.spatialVolumes, var1, var2);
         class="kw">return true;
      }
   }

   class="kw">public class="kw">interface ScheduledGateAction {
      void execute(
         @Nonnull Ref<EntityStore> var1,
         @Nonnull UUID var2,
         @Nonnull TriggerEventType var3,
         @Nonnull VolumeEntry var4,
         @Nullable List<VolumeEntry> var5,
         @Nonnull Store<EntityStore> var6,
         long var7
      );
   }

   class="kw">private class="kw">interface ScheduledItem class="kw">extends Comparable<DelayedEffectScheduler.ScheduledItem> {
      long executeAtNanos();

      @Nullable
      Ref<EntityStore> entityRef();

      @Nonnull
      UUID entityUuid();

      @Nonnull
      VolumeEntry volume();

      @Nonnull
      TriggerEventType eventType();

      boolean execute(@Nonnull Store<EntityStore> var1, long var2);

      class="kw">default void onFinished(boolean var1, long var2) {
      }

      class="kw">default int compareTo(@Nonnull DelayedEffectScheduler.ScheduledItem var1) {
         class="kw">return Long.compare(this.executeAtNanos(), var1.executeAtNanos());
      }
   }
}