class="kw">package com.hypixel.hytale.builtin.adventure.worldevents.condition;

class="kw">import com.hypixel.hytale.builtin.adventure.worldevents.context.ContextKey;
class="kw">import com.hypixel.hytale.builtin.adventure.worldevents.context.IntervalContext;
class="kw">import com.hypixel.hytale.builtin.adventure.worldevents.event.Validator;
class="kw">import com.hypixel.hytale.builtin.adventure.worldevents.event.WorldEvent;
class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import java.time.Duration;
class="kw">import java.util.concurrent.ThreadLocalRandom;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class IntervalCondition class="kw">implements EventCondition.Ticking {
   class="kw">public class="kw">static class="kw">final String ID = "IntervalCondition";
   class="kw">public class="kw">static class="kw">final EventCondition.Type TYPE = new EventCondition.Type("IntervalCondition", 0.033333335F);
   class="kw">public class="kw">static class="kw">final BuilderCodec<IntervalCondition> CODEC = BuilderCodec.builder(IntervalCondition.class, IntervalCondition::new)
      .append(new KeyedCodec<>("RemainingSeconds", Codec.FLOAT), (var0, var1) -> var0.interval.setOrNull(var1), var0 -> var0.interval.getOrNull())
      .documentation("The remaining seconds for the interval.")
      .add()
      .build();
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   @Nonnull
   class="kw">public IntervalCondition.Config config = IntervalCondition.Config.EMPTY;
   @Nonnull
   class="kw">public class="kw">final IntervalContext interval = new IntervalContext();

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

   @Override
   class="kw">public boolean test() {
      class="kw">return this.interval.elapsed();
   }

   @Override
   class="kw">public void reset() {
      this.interval.reset();
   }

   @Override
   class="kw">public void tick(float var1, @Nonnull Store<EntityStore> var2) {
      this.interval.sub(var1);
   }

   @Override
   class="kw">public boolean onStart(@Nonnull WorldEvent var1) {
      if (this.interval.uninitialized()) {
         this.interval.set((float)this.config.nextRandomSeconds());
      }

      if (this.config.intervalKey != null) {
         var1.context.put(this.config.intervalKey, this.interval);
      }

      class="kw">return true;
   }

   @Override
   class="kw">public boolean onComplete(@Nonnull WorldEvent var1) {
      if (this.config.intervalKey != null) {
         var1.context.remove(this.config.intervalKey, IntervalContext.class);
      }

      class="kw">return true;
   }

   @Override
   class="kw">public void onCancel(@Nonnull WorldEvent var1) {
      if (this.config.intervalKey != null) {
         var1.context.remove(this.config.intervalKey, IntervalContext.class);
      }
   }

   @Override
   class="kw">public void merge(@Nonnull EventCondition var1) {
      if (var1 class="kw">instanceof IntervalCondition var2) {
         this.interval.set(var2.interval.get());
      }
   }

   class="kw">public class="kw">static class Config class="kw">implements EventCondition.Config {
      class="kw">public class="kw">static class="kw">final BuilderCodec<IntervalCondition.Config> CODEC = BuilderCodec.builder(IntervalCondition.Config.class, IntervalCondition.Config::new)
         .documentation("A condition that completes after a configurable time interval.")
         .<ContextKey>append(new KeyedCodec<>("IntervalKey", ContextKey.CODEC), (var0, var1) -> var0.intervalKey = var1, var0 -> var0.intervalKey)
         .documentation("Define a variable name for this interval timer that other actions and conditions can refer to.")
         .add()
         .<Duration>append(new KeyedCodec<>("MinSeconds", Codec.DURATION_SECONDS), (var0, var1) -> var0.intervalMin = var1, var0 -> var0.intervalMin)
         .documentation("The minimum duration of the interval in seconds.")
         .add()
         .<Duration>append(new KeyedCodec<>("MaxSeconds", Codec.DURATION_SECONDS), (var0, var1) -> var0.intervalMax = var1, var0 -> var0.intervalMax)
         .documentation("The maximum duration of the interval in seconds.")
         .add()
         .build();
      class="kw">protected class="kw">static class="kw">final IntervalCondition.Config EMPTY = new IntervalCondition.Config();
      class="kw">protected class="kw">static class="kw">final Duration DEFAULT_DURATION = Duration.ofSeconds(0L);
      @Nullable
      class="kw">protected ContextKey intervalKey = null;
      @Nonnull
      class="kw">protected Duration intervalMin = DEFAULT_DURATION;
      @Nonnull
      class="kw">protected Duration intervalMax = DEFAULT_DURATION;

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

      class="kw">public long nextRandomSeconds() {
         long var1 = this.intervalMin.toSeconds();
         long var3 = this.intervalMax.toSeconds();
         class="kw">return var1 >= var3 ? var3 : ThreadLocalRandom.current().nextLong(var1, var3 + 1L);
      }

      @Nonnull
      @Override
      class="kw">public EventCondition create() {
         IntervalCondition var1 = new IntervalCondition();
         var1.config = this;
         class="kw">return var1;
      }

      @Override
      class="kw">public void validate(@Nonnull Validator var1) {
         if (this.intervalMin.toSeconds() > this.intervalMax.toSeconds()) {
            ((HytaleLogger.Api)IntervalCondition.LOGGER.atWarning()).log("IntervalCondition's min is greater than its max. It will be clamped to max.");
         }
      }
   }
}