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

class="kw">import com.hypixel.hytale.builtin.adventure.memories.commands.MemoriesCommand;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.component.PlayerMemories;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.interactions.MemoriesConditionInteraction;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.interactions.SetMemoriesCapacityInteraction;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.memories.Memory;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.memories.MemoryProvider;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.memories.npc.NPCMemory;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.memories.npc.NPCMemoryProvider;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.page.MemoriesPage;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.page.MemoriesPageSupplier;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.page.MemoriesUnlockedPage;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.page.MemoriesUnlockedPageSuplier;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.temple.ForgottenTempleConfig;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.temple.TempleRespawnPlayersSystem;
class="kw">import com.hypixel.hytale.builtin.adventure.memories.window.MemoriesWindow;
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.codec.codecs.array.ArrayCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.Object2DoubleMapCodec;
class="kw">import com.hypixel.hytale.common.util.PathUtil;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentRegistryProxy;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.RemoveReason;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.component.dependency.Dependency;
class="kw">import com.hypixel.hytale.component.dependency.Order;
class="kw">import com.hypixel.hytale.component.dependency.SystemDependency;
class="kw">import com.hypixel.hytale.component.query.Query;
class="kw">import com.hypixel.hytale.component.system.RefSystem;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.protocol.packets.player.UpdateMemoriesCount;
class="kw">import com.hypixel.hytale.protocol.packets.player.UpdateMemoriesFeatureStatus;
class="kw">import com.hypixel.hytale.protocol.packets.window.WindowType;
class="kw">import com.hypixel.hytale.server.core.Constants;
class="kw">import com.hypixel.hytale.server.core.HytaleServer;
class="kw">import com.hypixel.hytale.server.core.HytaleServerConfig;
class="kw">import com.hypixel.hytale.server.core.Options;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.entities.player.windows.Window;
class="kw">import com.hypixel.hytale.server.core.io.PacketHandler;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.player.PlayerSystems;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.server.OpenCustomUIInteraction;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPlugin;
class="kw">import com.hypixel.hytale.server.core.plugin.JavaPluginInit;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.resources.DefaultUniverseResourceStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.resources.DiskUniverseResourceStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.resources.IUniverseResourceStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.resources.UniverseResourceType;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.util.Config;
class="kw">import com.hypixel.hytale.server.npc.AllNPCsLoadedEvent;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleMaps;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectRBTreeMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.nio.file.StandardCopyOption;
class="kw">import java.util.Collections;
class="kw">import java.util.HashSet;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.locks.ReentrantReadWriteLock;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class MemoriesPlugin class="kw">extends JavaPlugin {
   @Nonnull
   class="kw">public class="kw">static class="kw">final String MEMORIES_JSON_PATH = "memories.json";
   @Nonnull
   class="kw">public class="kw">static class="kw">final String RECORDED_MEMORIES_ID = "Memories";
   class="kw">private class="kw">static MemoriesPlugin instance;
   @Nonnull
   class="kw">private class="kw">final Config<MemoriesPlugin.MemoriesPluginConfig> config = this.withConfig(MemoriesPlugin.MemoriesPluginConfig.CODEC);
   @Nonnull
   class="kw">private class="kw">final List<MemoryProvider<?>> providers = new ObjectArrayList();
   @Nonnull
   class="kw">private class="kw">final Map<String, Set<Memory>> allMemories = new Object2ObjectRBTreeMap();
   class="kw">private ComponentType<EntityStore, PlayerMemories> playerMemoriesComponentType;
   class="kw">private UniverseResourceType<MemoriesPlugin.RecordedMemories> recordedMemoriesType;
   @Nullable
   class="kw">private MemoriesPlugin.RecordedMemories recordedMemories;
   class="kw">private boolean hasInitializedMemories;

   class="kw">public class="kw">static MemoriesPlugin get() {
      class="kw">return instance;
   }

   class="kw">public MemoriesPlugin(@Nonnull JavaPluginInit var1) {
      super(var1);
      instance = this;
   }

   @Override
   class="kw">protected void setup() {
      this.migrateLegacyMemoriesFile();
      this.recordedMemoriesType = Universe.registerResource(MemoriesPlugin.RecordedMemories.class, "Memories", MemoriesPlugin.RecordedMemories.CODEC);
      ComponentRegistryProxy var1 = this.getEntityStoreRegistry();
      this.getCommandRegistry().registerCommand(new MemoriesCommand());
      OpenCustomUIInteraction.registerCustomPageSupplier(this, MemoriesPage.class, "Memories", new MemoriesPageSupplier());
      OpenCustomUIInteraction.registerCustomPageSupplier(this, MemoriesUnlockedPage.class, "MemoriesUnlocked", new MemoriesUnlockedPageSuplier());
      Window.CLIENT_REQUESTABLE_WINDOW_TYPES.put(WindowType.Memories, MemoriesWindow::new);
      this.playerMemoriesComponentType = var1.registerComponent(PlayerMemories.class, "PlayerMemories", PlayerMemories.CODEC);
      ComponentType var2 = Player.getComponentType();
      ComponentType var3 = PlayerRef.getComponentType();
      ComponentType var4 = TransformComponent.getComponentType();
      NPCMemoryProvider var5 = new NPCMemoryProvider();
      this.registerMemoryProvider(var5);
      var1.registerSystem(new NPCMemory.GatherMemoriesSystem(var4, var2, var3, this.playerMemoriesComponentType, var5.getCollectionRadius()));

      for (MemoryProvider var7 : this.providers) {
         BuilderCodec var8 = (BuilderCodec<? class="kw">extends Memory>)var7.getCodec();
         this.getCodecRegistry(Memory.CODEC).register(var7.getId(), var8.getInnerClass(), var8);
      }

      this.getEventRegistry().register(AllNPCsLoadedEvent.class, var1x -> this.onAssetsLoad());
      var1.registerSystem(new MemoriesPlugin.PlayerAddedSystem(var2, var3, this.playerMemoriesComponentType));
      this.getCodecRegistry(Interaction.CODEC).register("SetMemoriesCapacity", SetMemoriesCapacityInteraction.class, SetMemoriesCapacityInteraction.CODEC);
      this.getCodecRegistry(GameplayConfig.PLUGIN_CODEC).register(MemoriesGameplayConfig.class, "Memories", MemoriesGameplayConfig.CODEC);
      this.getCodecRegistry(Interaction.CODEC).register("MemoriesCondition", MemoriesConditionInteraction.class, MemoriesConditionInteraction.CODEC);
      var1.registerSystem(new TempleRespawnPlayersSystem(var3, var4));
      this.getCodecRegistry(GameplayConfig.PLUGIN_CODEC).register(ForgottenTempleConfig.class, "ForgottenTemple", ForgottenTempleConfig.CODEC);
   }

   @Override
   class="kw">protected void start() {
      this.recordedMemories = Universe.get().getResource(this.recordedMemoriesType);
      this.hasInitializedMemories = true;
      this.onAssetsLoad();
   }

   @Nonnull
   class="kw">private CompletableFuture<Void> saveMemories() {
      class="kw">return Universe.get().flushResource(this.recordedMemoriesType).exceptionally(var1 -> {
         ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var1)).log("Failed to save memories");
         class="kw">return null;
      });
   }

   class="kw">private void migrateLegacyMemoriesFile() {
      if (!Options.isBare()) {
         HytaleServerConfig var1 = HytaleServer.get().getConfig();
         if (var1 != null) {
            Path var2 = resolveDiskResourceDirectory(var1.getUniverseResourceStorageProvider());
            if (var2 == null) {
               if (Files.exists(Constants.UNIVERSE_PATH.resolve("memories.json"))) {
                  this.getLogger().at(Level.WARNING).log("Legacy memories file %s cannot migrate to a custom universe resource storage", "memories.json");
               }
            } else if (PathUtil.isInTrustedRoot(var2)) {
               migrateLegacyMemoriesFile(Constants.UNIVERSE_PATH, var2, this.getLogger());
            }
         }
      }
   }

   class="kw">private void onAssetsLoad() {
      if (this.hasInitializedMemories) {
         this.allMemories.clear();

         for (MemoryProvider var2 : this.providers) {
            for (Entry var4 : var2.getAllMemories().entrySet()) {
               this.allMemories.computeIfAbsent(var4.getKey(), var0 -> new HashSet<>()).addAll(var4.getValue());
            }
         }
      }
   }

   class="kw">public MemoriesPlugin.MemoriesPluginConfig getConfig() {
      class="kw">return this.config.get();
   }

   class="kw">public ComponentType<EntityStore, PlayerMemories> getPlayerMemoriesComponentType() {
      class="kw">return this.playerMemoriesComponentType;
   }

   class="kw">public <T class="kw">extends Memory> void registerMemoryProvider(MemoryProvider<T> var1) {
      this.providers.add(var1);
   }

   @Nonnull
   class="kw">public Map<String, Set<Memory>> getAllMemories() {
      class="kw">return this.allMemories;
   }

   class="kw">public int getMemoriesLevel(@Nonnull GameplayConfig var1) {
      MemoriesGameplayConfig var2 = MemoriesGameplayConfig.get(var1);
      int var3 = 1;
      if (var2 == null) {
         class="kw">return var3;
      }

      int var4 = this.getRecordedMemories().size();
      int[] var5 = var2.getMemoriesAmountPerLevel();

      for (int var6 = var5.length - 1; var6 >= 0; var6--) {
         if (var4 >= var5[var6]) {
            class="kw">return var6 + 2;
         }
      }

      class="kw">return var3;
   }

   class="kw">public boolean hasRecordedMemory(Memory var1) {
      this.recordedMemories.lock.readLock().lock();

      try {
         class="kw">return this.recordedMemories.memories.contains(var1);
      } class="kw">finally {
         this.recordedMemories.lock.readLock().unlock();
      }
   }

   class="kw">public boolean recordPlayerMemories(@Nonnull PlayerMemories var1) {
      this.recordedMemories.lock.writeLock().lock();

      boolean var2;
      try {
         var2 = var1.takeMemories(this.recordedMemories.memories);
      } class="kw">finally {
         this.recordedMemories.lock.writeLock().unlock();
      }

      if (var2) {
         this.saveMemories();
      }

      class="kw">return var2;
   }

   @Nonnull
   class="kw">public Set<Memory> getRecordedMemories() {
      this.recordedMemories.lock.readLock().lock();

      try {
         class="kw">return new HashSet<>(this.recordedMemories.memories);
      } class="kw">finally {
         this.recordedMemories.lock.readLock().unlock();
      }
   }

   class="kw">public void clearRecordedMemories() {
      this.recordedMemories.lock.writeLock().lock();

      try {
         this.recordedMemories.memories.clear();
      } class="kw">finally {
         this.recordedMemories.lock.writeLock().unlock();
      }

      this.saveMemories();
   }

   class="kw">public void recordAllMemories() {
      this.recordedMemories.lock.writeLock().lock();

      try {
         for (Entry var2 : this.allMemories.entrySet()) {
            this.recordedMemories.memories.addAll(var2.getValue());
         }
      } class="kw">finally {
         this.recordedMemories.lock.writeLock().unlock();
      }

      this.saveMemories();
   }

   class="kw">public int setRecordedMemoriesCount(int var1) {
      if (var1 < 0) {
         var1 = 0;
      }

      this.recordedMemories.lock.writeLock().lock();

      int var2;
      try {
         this.recordedMemories.memories.clear();
         List var3 = new ObjectArrayList();

         for (Entry var5 : this.allMemories.entrySet()) {
            var3.addAll(var5.getValue());
         }

         var2 = Math.min(var1, var3.size());

         for (int var9 = 0; var9 < var2; var9++) {
            this.recordedMemories.memories.add(var3.get(var9));
         }
      } class="kw">finally {
         this.recordedMemories.lock.writeLock().unlock();
      }

      this.saveMemories();
      class="kw">return var2;
   }

   class="kw">static void migrateLegacyMemoriesFile(@Nonnull Path var0, @Nonnull Path var1, @Nonnull HytaleLogger var2) {
      Path var3 = var0.resolve("memories.json");
      Path var4 = var0.resolve("memories.json.bak");
      if (Files.exists(var3) || Files.exists(var4)) {
         Path var5 = var1.resolve("Memories.json");
         if (Files.exists(var5)) {
            var2.at(Level.WARNING).log("Legacy memories file %s was not migrated because %s already exists", var3, var5);
         } else {
            try {
               Files.createDirectories(var1);
               if (Files.exists(var3)) {
                  Files.move(var3, var5);
               }
            } catch (IOException var8) {
               throw new RuntimeException("Failed to migrate legacy memories file " + var3, var8);
            }

            if (Files.exists(var4)) {
               try {
                  Files.move(var4, var5.resolveSibling(var5.getFileName() + ".bak"), StandardCopyOption.REPLACE_EXISTING);
               } catch (IOException var7) {
                  ((HytaleLogger.Api)var2.at(Level.WARNING).withCause(var7)).log("Failed to migrate legacy memories backup file %s", var4);
               }
            }
         }
      }
   }

   @Nullable
   class="kw">private class="kw">static Path resolveDiskResourceDirectory(@Nonnull IUniverseResourceStorageProvider var0) {
      if (var0 class="kw">instanceof DiskUniverseResourceStorageProvider var1) {
         class="kw">return var1.getPath();
      } else {
         class="kw">return var0 class="kw">instanceof DefaultUniverseResourceStorageProvider ? DefaultUniverseResourceStorageProvider.DEFAULT.getPath() : null;
      }
   }

   class="kw">public class="kw">static class MemoriesPluginConfig {
      @Nonnull
      class="kw">public class="kw">static class="kw">final BuilderCodec<MemoriesPlugin.MemoriesPluginConfig> CODEC = BuilderCodec.builder(
            MemoriesPlugin.MemoriesPluginConfig.class, MemoriesPlugin.MemoriesPluginConfig::new
         )
         .append(
            new KeyedCodec<>("CollectionRadius", new Object2DoubleMapCodec<>(Codec.STRING, Object2DoubleOpenHashMap::new)),
            (var0, var1) -> var0.collectionRadius = var1,
            var0 -> var0.collectionRadius
         )
         .add()
         .build();
      class="kw">private Object2DoubleMap<String> collectionRadius;

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

      @Nonnull
      class="kw">public Object2DoubleMap<String> getCollectionRadius() {
         class="kw">return (Object2DoubleMap<String>)(this.collectionRadius != null ? this.collectionRadius : Object2DoubleMaps.EMPTY_MAP);
      }
   }

   class="kw">public class="kw">static class PlayerAddedSystem class="kw">extends RefSystem<EntityStore> {
      @Nonnull
      class="kw">private class="kw">final Set<Dependency<EntityStore>> dependencies = Set.of(new SystemDependency<>(Order.AFTER, PlayerSystems.PlayerSpawnedSystem.class));
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, Player> playerComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, PlayerRef> playerRefComponentType;
      @Nonnull
      class="kw">private class="kw">final ComponentType<EntityStore, PlayerMemories> playerMemoriesComponentType;
      @Nonnull
      class="kw">private class="kw">final Query<EntityStore> query;

      class="kw">public PlayerAddedSystem(
         @Nonnull ComponentType<EntityStore, Player> var1,
         @Nonnull ComponentType<EntityStore, PlayerRef> var2,
         @Nonnull ComponentType<EntityStore, PlayerMemories> var3
      ) {
         this.playerComponentType = var1;
         this.playerRefComponentType = var2;
         this.playerMemoriesComponentType = var3;
         this.query = Query.and(var1, var2);
      }

      @Nonnull
      @Override
      class="kw">public Query<EntityStore> getQuery() {
         class="kw">return this.query;
      }

      @Nonnull
      @Override
      class="kw">public Set<Dependency<EntityStore>> getDependencies() {
         class="kw">return this.dependencies;
      }

      @Override
      class="kw">public void onEntityAdded(
         @Nonnull Ref<EntityStore> var1, @Nonnull AddReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
         Player var5 = var3.getComponent(var1, this.playerComponentType);
         assert var5 != null;
         PlayerRef var6 = var3.getComponent(var1, this.playerRefComponentType);
         assert var6 != null;
         PlayerMemories var7 = var3.getComponent(var1, this.playerMemoriesComponentType);
         boolean var8 = var7 != null;
         PacketHandler var9 = var6.getPacketHandler();
         var9.writeNoCache(new UpdateMemoriesFeatureStatus(var8));
         int var10 = var7 != null ? var7.getRecordedMemories().size() : 0;
         var9.writeNoCache(new UpdateMemoriesCount(var10));
      }

      @Override
      class="kw">public void onEntityRemove(
         @Nonnull Ref<EntityStore> var1, @Nonnull RemoveReason var2, @Nonnull Store<EntityStore> var3, @Nonnull CommandBuffer<EntityStore> var4
      ) {
      }
   }

   class="kw">private class="kw">static class RecordedMemories {
      @Nonnull
      class="kw">public class="kw">static class="kw">final BuilderCodec<MemoriesPlugin.RecordedMemories> CODEC = BuilderCodec.builder(
            MemoriesPlugin.RecordedMemories.class, MemoriesPlugin.RecordedMemories::new
         )
         .append(new KeyedCodec<>("Memories", new ArrayCodec<>(Memory.CODEC, Memory[]::new)), (var0, var1) -> {
            if (var1 != null) {
               Collections.addAll(var0.memories, var1);
            }
         }, var0 -> {
            var0.lock.readLock().lock();

            try {
               class="kw">return var0.memories.toArray(Memory[]::new);
            } class="kw">finally {
               var0.lock.readLock().unlock();
            }
         })
         .add()
         .build();
      @Nonnull
      class="kw">private class="kw">final ReentrantReadWriteLock lock = new ReentrantReadWriteLock();
      @Nonnull
      class="kw">private class="kw">final Set<Memory> memories = new HashSet<>();

      class="kw">private RecordedMemories() {
      }
   }
}