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

class="kw">import com.hypixel.hytale.builtin.adventure.worldevents.event.WorldEvent;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.component.Resource;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import it.unimi.dsi.fastutil.Hash.Strategy;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectOpenCustomHashSet;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectSet;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.atomic.AtomicBoolean;
class="kw">import java.util.concurrent.atomic.AtomicReference;
class="kw">import java.util.function.BiConsumer;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import javax.annotation.concurrent.NotThreadSafe;

@NotThreadSafe
class="kw">public class WorldEventStorage class="kw">implements Resource<EntityStore> {
   class="kw">public class="kw">static class="kw">final String ID = "WorldEventStorage";
   class="kw">public class="kw">static class="kw">final BuilderCodec<WorldEventStorage> CODEC = BuilderCodec.builder(WorldEventStorage.class, WorldEventStorage::new)
      .append(new KeyedCodec<>("Active", WorldEvent.ARRAY_CODEC), WorldEventStorage::setEvents, WorldEventStorage::getEvents)
      .documentation("The world events stored in the storage.")
      .add()
      .append(
         new KeyedCodec<>("Complete", new ArrayCodec<>(BuilderCodec.UUID_STRING, UUID[]::new)), WorldEventStorage::setComplete, WorldEventStorage::getComplete
      )
      .documentation("The completed events")
      .add()
      .build();
   class="kw">private class="kw">static class="kw">final HytaleLogger LOGGER = HytaleLogger.forEnclosingClass();
   class="kw">protected class="kw">static class="kw">final Strategy<WorldEvent> HASH_STRATEGY = new Strategy<WorldEvent>() {
      class="kw">public int hashCode(@Nullable WorldEvent var1) {
         class="kw">return var1 == null ? Integer.MIN_VALUE : var1.uuid.hashCode();
      }

      class="kw">public boolean equals(@Nullable WorldEvent var1, @Nullable WorldEvent var2) {
         class="kw">return var1 == var2 || var1 != null && var2 != null && var1.uuid.equals(var2.uuid);
      }
   };
   class="kw">protected class="kw">final AtomicBoolean load = new AtomicBoolean();
   class="kw">protected class="kw">final AtomicBoolean save = new AtomicBoolean();
   class="kw">protected class="kw">final ObjectSet<UUID> complete = new ObjectOpenHashSet();
   class="kw">protected class="kw">final ObjectSet<WorldEvent> events = new ObjectOpenCustomHashSet(HASH_STRATEGY);
   class="kw">protected class="kw">final AtomicReference<WorldEventStorage.State> state = new AtomicReference<>(WorldEventStorage.State.LOADED);

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

   class="kw">public WorldEventStorage(@Nonnull WorldEventStorage var1) {
      this.events.addAll(var1.events);
      this.complete.addAll(var1.complete);
   }

   class="kw">public void clear() {
      this.events.clear();
      this.complete.clear();
      this.markSave();
   }

   @Nonnull
   class="kw">public WorldEventStorage.State consumeState() {
      if (this.save.get() && this.state.compareAndSet(WorldEventStorage.State.IDLE, WorldEventStorage.State.SAVE)) {
         this.save.set(false);
      } else if (this.load.get() && this.state.compareAndSet(WorldEventStorage.State.IDLE, WorldEventStorage.State.LOAD)) {
         this.load.set(false);
      }

      class="kw">return this.state.getAndUpdate(var0 -> {
         class="kw">return class="kw">switch (var0) {
            case SAVE, SAVING -> WorldEventStorage.State.SAVING;
            case LOAD, LOADING -> WorldEventStorage.State.LOADING;
            class="kw">default -> WorldEventStorage.State.IDLE;
         };
      });
   }

   class="kw">public void markLoad() {
      this.load.set(true);
   }

   class="kw">public void markSave() {
      this.save.set(true);
   }

   class="kw">public void add(@Nonnull WorldEvent var1) {
      if (!var1.uuid.equals(WorldEvent.EMPTY_ID)) {
         if (this.events.add(var1)) {
            this.markSave();
         }
      }
   }

   class="kw">public void remove(@Nonnull WorldEvent var1) {
      if (!var1.uuid.equals(WorldEvent.EMPTY_ID)) {
         if (this.events.remove(var1)) {
            this.markSave();
         }
      }
   }

   class="kw">public boolean contains(@Nonnull WorldEvent var1) {
      class="kw">return !var1.uuid.equals(WorldEvent.EMPTY_ID) && this.events.contains(var1);
   }

   class="kw">public <T> void forEach(@Nullable T var1, @Nonnull BiConsumer<WorldEvent, T> var2) {
      ObjectIterator var3 = this.events.iterator();

      while (var3.hasNext()) {
         WorldEvent var4 = (WorldEvent)var3.next();
         var2.accept(var4, var1);
      }
   }

   class="kw">public void addComplete(@Nonnull UUID var1) {
      if (this.complete.add(var1)) {
         this.markSave();
      }
   }

   class="kw">public boolean isComplete(@Nonnull UUID var1) {
      class="kw">return this.complete.contains(var1);
   }

   class="kw">public int completeCount() {
      class="kw">return this.complete.size();
   }

   class="kw">public void onCompleteSave(@Nullable Object var1, @Nullable Throwable var2) {
      WorldEventStorage.State var3 = this.state.getAndSet(WorldEventStorage.State.IDLE);
      assert var3 == WorldEventStorage.State.SAVING : "WorldEventStorage was in invalid state. onCompleteSave called but oldState was not SAVING";
      if (var2 != null) {
         ((HytaleLogger.Api)((HytaleLogger.Api)LOGGER.atWarning()).withCause(var2)).log("An error occurred whilst saving the WorldEventStorage");
      }
   }

   class="kw">public void onCompleteLoad(@Nullable WorldEventStorage var1, @Nullable Throwable var2) {
      WorldEventStorage.State var3 = this.state.getAndSet(WorldEventStorage.State.LOADED);
      assert var3 == WorldEventStorage.State.LOADING : "WorldEventStorage was in invalid state. onCompleteLoad called but oldState was not LOADING";
      if (var1 != null) {
         this.events.clear();
         this.events.addAll(var1.events);
         this.complete.clear();
         this.complete.addAll(var1.complete);
      }

      if (var2 != null) {
         ((HytaleLogger.Api)((HytaleLogger.Api)LOGGER.atWarning()).withCause(var2)).log("An error occurred whilst loading the WorldEventStorage");
      }
   }

   @Nonnull
   class="kw">protected WorldEvent[] getEvents() {
      class="kw">return (WorldEvent[])this.events.toArray(WorldEvent.EMPTY_ARRAY);
   }

   class="kw">protected void setEvents(@Nonnull WorldEvent[] var1) {
      this.events.clear();
      Collections.addAll(this.events, var1);
   }

   @Nonnull
   class="kw">public UUID[] getComplete() {
      UUID[] var1 = (UUID[])this.complete.toArray(UUID[]::new);
      Arrays.sort(var1);
      class="kw">return var1;
   }

   class="kw">protected void setComplete(@Nonnull UUID[] var1) {
      this.complete.clear();
      Collections.addAll(this.complete, var1);
   }

   @Nonnull
   @Override
   class="kw">public Resource<EntityStore> clone() {
      class="kw">return new WorldEventStorage(this);
   }

   class="kw">public class="kw">static ResourceType<EntityStore, WorldEventStorage> getResourceType() {
      class="kw">return WorldEventsPlugin.get().getWorldEventStorageResourceType();
   }

   class="kw">public enum State {
      IDLE,
      SAVE,
      SAVING,
      LOAD,
      LOADING,
      LOADED;

      State() {
      }
   }
}