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

class="kw">import com.hypixel.hytale.assetstore.event.LoadedAssetsEvent;
class="kw">import com.hypixel.hytale.assetstore.map.DefaultAssetMap;
class="kw">import com.hypixel.hytale.builtin.teleport.commands.teleport.SpawnCommand;
class="kw">import com.hypixel.hytale.builtin.teleport.commands.teleport.TeleportCommand;
class="kw">import com.hypixel.hytale.builtin.teleport.commands.warp.WarpCommand;
class="kw">import com.hypixel.hytale.builtin.teleport.components.TeleportHistory;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.Component;
class="kw">import com.hypixel.hytale.component.ComponentType;
class="kw">import com.hypixel.hytale.component.Holder;
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.event.EventRegistry;
class="kw">import com.hypixel.hytale.logger.HytaleLogger;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.protocol.packets.worldmap.MapMarker;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.GameplayConfig;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.Model;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandRegistry;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.entity.nameplate.Nameplate;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.BoundingBox;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.HiddenFromAdventurePlayers;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.Intangible;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.ModelComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.tracker.NetworkId;
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.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.ChunkColumn;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.EntitySection;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.AddWorldEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.AllWorldsLoadedEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.ChunkPreLoadProcessEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldmap.WorldMapManager;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldmap.markers.MapMarkerBuilder;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldmap.markers.MarkersCollector;
class="kw">import com.hypixel.hytale.server.core.util.BsonUtil;
class="kw">import java.io.IOException;
class="kw">import java.nio.file.Files;
class="kw">import java.nio.file.Path;
class="kw">import java.util.Locale;
class="kw">import java.util.Map;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.atomic.AtomicBoolean;
class="kw">import java.util.logging.Level;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.bson.BsonArray;
class="kw">import org.bson.BsonDocument;
class="kw">import org.joml.Vector3d;

class="kw">public class TeleportPlugin class="kw">extends JavaPlugin {
   class="kw">private class="kw">static TeleportPlugin instance;
   class="kw">public class="kw">static class="kw">final String WARP_MODEL_ID = "Warp";
   class="kw">private ComponentType<EntityStore, TeleportHistory> teleportHistoryComponentType;
   class="kw">private ComponentType<EntityStore, TeleportPlugin.WarpComponent> warpComponentType;
   @Nonnull
   class="kw">private class="kw">final AtomicBoolean loaded = new AtomicBoolean();
   @Nonnull
   class="kw">private class="kw">final Map<String, Warp> warps = new ConcurrentHashMap<>();
   class="kw">private Model warpModel;

   @Nonnull
   class="kw">public class="kw">static TeleportPlugin get() {
      class="kw">return instance;
   }

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

   @Nonnull
   class="kw">public ComponentType<EntityStore, TeleportHistory> getTeleportHistoryComponentType() {
      class="kw">return this.teleportHistoryComponentType;
   }

   class="kw">public boolean isWarpsLoaded() {
      class="kw">return this.loaded.get();
   }

   @Override
   class="kw">protected void setup() {
      instance = this;
      CommandRegistry var1 = this.getCommandRegistry();
      EventRegistry var2 = this.getEventRegistry();
      var1.registerCommand(new TeleportCommand());
      var1.registerCommand(new WarpCommand());
      var1.registerCommand(new SpawnCommand());
      var2.register(LoadedAssetsEvent.class, ModelAsset.class, this::onModelAssetChange);
      var2.registerGlobal(ChunkPreLoadProcessEvent.class, this::onChunkPreLoadProcess);
      var2.registerGlobal(
         AddWorldEvent.class, var0 -> var0.getWorld().getWorldMapManager().addMarkerProvider("warps", TeleportPlugin.WarpMarkerProvider.INSTANCE)
      );
      var2.registerGlobal(AllWorldsLoadedEvent.class, var1x -> this.loadWarps());
      this.teleportHistoryComponentType = EntityStore.REGISTRY.registerComponent(TeleportHistory.class, TeleportHistory::new);
      this.warpComponentType = EntityStore.REGISTRY.registerComponent(TeleportPlugin.WarpComponent.class, () -> {
         throw new UnsupportedOperationException("WarpComponent must be created manually");
      });
   }

   @Override
   class="kw">protected void start() {
      ModelAsset var1 = ModelAsset.getAssetMap().getAsset("Warp");
      if (var1 == null) {
         throw new IllegalStateException(String.format("Default warp model '%s' not found", "Warp"));
      }

      this.warpModel = Model.createUnitScaleModel(var1);
   }

   @Override
   class="kw">protected void shutdown() {
   }

   class="kw">public void loadWarps() {
      BsonDocument var1 = null;
      Path var2 = Universe.get().getPath();
      Path var3 = var2.resolve("warps.bson");
      Path var4 = var2.resolve("warps.json");
      if (Files.exists(var3) && !Files.exists(var4)) {
         try {
            Files.move(var3, var4);
         } catch (IOException var10) {
         }
      }

      if (Files.exists(var4)) {
         var1 = BsonUtil.readDocument(var4).join();
      }

      if (var1 != null) {
         BsonArray var5 = var1.containsKey("Warps") ? var1.getArray("Warps") : var1.getArray("warps");
         this.warps.clear();

         for (Warp var9 : Warp.ARRAY_CODEC.decode(var5)) {
            this.warps.put(var9.getId().toLowerCase(Locale.ROOT), var9);
         }

         this.getLogger().at(Level.INFO).log("Loaded %d warps", var5.size());
      } else {
         this.getLogger().at(Level.INFO).log("Loaded 0 warps (No warps.json found)");
      }

      this.loaded.set(true);
   }

   class="kw">public void saveWarps() {
      Path var1 = Universe.get().getPath().resolve("warps.json");
      Universe.get().getStorageManager().doSave(var1, () -> {
         Warp[] var2 = this.warps.values().toArray(Warp[]::new);
         BsonDocument var3 = new BsonDocument("Warps", Warp.ARRAY_CODEC.encode(var2));
         this.getLogger().at(Level.INFO).log("Saving %d warps to warps.json", var2.length);
         class="kw">return BsonUtil.writeDocument(var1, var3);
      }).exceptionally(var1x -> {
         ((HytaleLogger.Api)this.getLogger().at(Level.SEVERE).withCause(var1x)).log("Failed to save warps");
         class="kw">return null;
      });
   }

   class="kw">public Map<String, Warp> getWarps() {
      class="kw">return this.warps;
   }

   class="kw">private void onModelAssetChange(@Nonnull LoadedAssetsEvent<String, ModelAsset, DefaultAssetMap<String, ModelAsset>> var1) {
      Map var2 = var1.getLoadedAssets();
      ModelAsset var3 = var2.get("Warp");
      if (var3 != null) {
         this.warpModel = Model.createUnitScaleModel(var3);
      }
   }

   class="kw">private void onChunkPreLoadProcess(@Nonnull ChunkPreLoadProcessEvent var1) {
      WorldChunk var2 = var1.getChunk();
      BlockChunk var3 = var2.getBlockChunk();
      if (var3 != null) {
         int var4 = var3.getX();
         int var5 = var3.getZ();
         World var6 = var2.getWorld();
         String var7 = var6.getName();
         ChunkColumn var8 = var1.getHolder().getComponent(ChunkColumn.getComponentType());
         assert var8 != null;
         Holder[] var9 = var8.getSectionHolders();
         if (var9 != null) {
            for (Entry var11 : this.warps.entrySet()) {
               Warp var12 = var11.getValue();
               Transform var13 = var12.getTransform();
               if (var13 != null) {
                  Vector3d var14 = var13.getPosition();
                  if (ChunkUtil.isInsideChunk(var4, var5, MathUtil.floor(var14.x), MathUtil.floor(var14.z)) && var12.getWorld().equals(var7)) {
                     int var15 = ChunkUtil.chunkCoordinate(var14.y);
                     if (var15 >= 0 && var15 < var9.length) {
                        Holder var16 = var9[var15];
                        if (var16 != null) {
                           EntitySection var17 = var16.ensureAndGetComponent(EntitySection.getComponentType());
                           var17.loadEntityHolder(this.createWarp(var12, var6.getEntityStore().getStore()));
                        }
                     }
                  }
               }
            }
         }
      }
   }

   @Nonnull
   class="kw">public Holder<EntityStore> createWarp(@Nonnull Warp var1, @Nonnull Store<EntityStore> var2) {
      Transform var3 = var1.getTransform();
      Holder var4 = EntityStore.REGISTRY.newHolder();
      Rotation3f var5 = var3.getRotation();
      Rotation3f var6 = new Rotation3f(
         Float.isFinite(var5.pitch()) ? var5.pitch() : 0.0F, Float.isFinite(var5.yaw()) ? var5.yaw() : 0.0F, Float.isFinite(var5.roll()) ? var5.roll() : 0.0F
      );
      var4.addComponent(TransformComponent.getComponentType(), new TransformComponent(var3.getPosition(), var6));
      var4.addComponent(NetworkId.getComponentType(), new NetworkId(var2.getExternalData().takeNextNetworkId()));
      var4.ensureComponent(Intangible.getComponentType());
      var4.addComponent(BoundingBox.getComponentType(), new BoundingBox(this.warpModel.getBoundingBox()));
      var4.addComponent(ModelComponent.getComponentType(), new ModelComponent(this.warpModel));
      var4.addComponent(Nameplate.getComponentType(), new Nameplate(var1.getId()));
      var4.ensureComponent(HiddenFromAdventurePlayers.getComponentType());
      var4.ensureComponent(EntityStore.REGISTRY.getNonSerializedComponentType());
      var4.addComponent(this.warpComponentType, new TeleportPlugin.WarpComponent(var1));
      class="kw">return var4;
   }

   class="kw">public boolean addWarp(@Nonnull Warp var1, boolean var2) {
      String var3 = var1.getId().toLowerCase(Locale.ROOT);
      Warp var4 = var2 ? this.warps.put(var3, var1) : this.warps.putIfAbsent(var3, var1);
      if (!var2 && var4 != null) {
         class="kw">return false;
      }

      if (var4 == null) {
         createWarpEntity(var1);
      } else {
         removeWarpEntity(var4).thenCompose(var1x -> createWarpEntity(var1));
      }

      this.saveWarps();
      class="kw">return true;
   }

   class="kw">public boolean removeWarp(@Nonnull String var1) {
      String var2 = var1.toLowerCase(Locale.ROOT);
      Warp var3 = this.warps.remove(var2);
      if (var3 == null) {
         class="kw">return false;
      }

      removeWarpEntity(var3);
      this.saveWarps();
      class="kw">return true;
   }

   class="kw">private class="kw">static CompletableFuture<Ref<EntityStore>> createWarpEntity(@Nonnull Warp var0) {
      World var1 = Universe.get().getWorld(var0.getWorld());
      class="kw">return var1 == null ? CompletableFuture.completedFuture(null) : CompletableFuture.supplyAsync(() -> createWarpEntity(var1, var0), var1);
   }

   class="kw">private class="kw">static CompletableFuture<Void> removeWarpEntity(@Nonnull Warp var0) {
      World var1 = Universe.get().getWorld(var0.getWorld());
      class="kw">return var1 == null ? CompletableFuture.completedFuture(null) : CompletableFuture.runAsync(() -> removeWarpEntity(var1, var0), var1);
   }

   @Nullable
   class="kw">private class="kw">static Ref<EntityStore> createWarpEntity(@Nonnull World var0, @Nonnull Warp var1) {
      assert var0.isInThread();
      Store var2 = var0.getEntityStore().getStore();
      TeleportPlugin var3 = get();
      Holder var4 = var3.createWarp(var1, var2);
      class="kw">return var2.addEntity(var4, AddReason.LOAD);
   }

   class="kw">private class="kw">static void removeWarpEntity(@Nonnull World var0, @Nonnull Warp var1) {
      assert var0.isInThread();
      Store var2 = var0.getEntityStore().getStore();
      ComponentType var3 = TeleportPlugin.WarpComponent.getComponentType();
      var2.forEachEntityParallel(var3, (var2x, var3x, var4) -> {
         TeleportPlugin.WarpComponent var5 = var3x.getComponent(var2x, var3);
         if (var5 != null && var5.warp().getId().equals(var1.getId())) {
            var4.removeEntity(var3x.getReferenceTo(var2x), RemoveReason.REMOVE);
         }
      });
   }

   class="kw">public record WarpComponent(Warp warp) class="kw">implements Component<EntityStore> {
      class="kw">public WarpComponent {
      }

      class="kw">public class="kw">static ComponentType<EntityStore, TeleportPlugin.WarpComponent> getComponentType() {
         class="kw">return TeleportPlugin.get().warpComponentType;
      }

      @Nonnull
      @Override
      class="kw">public Component<EntityStore> clone() {
         class="kw">return new TeleportPlugin.WarpComponent(this.warp);
      }
   }

   class="kw">public class="kw">static class WarpMarkerProvider class="kw">implements WorldMapManager.MarkerProvider {
      class="kw">public class="kw">static class="kw">final TeleportPlugin.WarpMarkerProvider INSTANCE = new TeleportPlugin.WarpMarkerProvider();

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

      @Override
      class="kw">public void update(@Nonnull World var1, @Nonnull Player var2, @Nonnull MarkersCollector var3) {
         Map var4 = TeleportPlugin.get().getWarps();
         if (!var4.isEmpty()) {
            GameplayConfig var5 = var1.getGameplayConfig();
            if (var5.getWorldMapConfig().isDisplayWarps()) {
               for (Warp var7 : var4.values()) {
                  if (var7.getWorld().equals(var1.getName())) {
                     MapMarker var8 = new MapMarkerBuilder("Warp-" + var7.getId(), "Warp.png", var7.getTransform())
                        .withName(Message.translation("server.map.warp").param("warpName", var7.getId()))
                        .build();
                     var3.add(var8);
                  }
               }
            }
         }
      }
   }
}