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

class="kw">import com.hypixel.hytale.assetstore.AssetRegistry;
class="kw">import com.hypixel.hytale.builtin.points.system.PointSpatialIndex;
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.map.MapCodec;
class="kw">import com.hypixel.hytale.component.Resource;
class="kw">import com.hypixel.hytale.protocol.packets.player.AddOrUpdatePointDisplay;
class="kw">import com.hypixel.hytale.protocol.packets.player.PointDisplayEntry;
class="kw">import com.hypixel.hytale.protocol.packets.player.RemovePointDisplay;
class="kw">import com.hypixel.hytale.protocol.packets.player.UpdatePointDisplay;
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.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collection;
class="kw">import java.util.Collections;
class="kw">import java.util.EnumSet;
class="kw">import java.util.HashSet;
class="kw">import java.util.LinkedHashMap;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.ThreadLocalRandom;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3f;

class="kw">public class PointManager class="kw">implements Resource<EntityStore> {
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<PointManager> CODEC = BuilderCodec.builder(PointManager.class, PointManager::new)
      .append(
         new KeyedCodec<>("Points", new MapCodec<>(PointEntry.CODEC, ConcurrentHashMap::new, false), false),
         (var0, var1) -> var0.points.putAll(var1),
         var0 -> var0.points.isEmpty() ? null : var0.points
      )
      .add()
      .afterDecode(PointManager::postDecode)
      .build();
   class="kw">private class="kw">static class="kw">final String ID_CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
   class="kw">private class="kw">static class="kw">final int ID_LENGTH = 6;
   class="kw">private class="kw">final Map<String, PointEntry> points = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<UUID, EnumSet<PointManager.ViewSource>> activeViewers = new ConcurrentHashMap<>();
   class="kw">private class="kw">final Map<UUID, String> playerSelections = new ConcurrentHashMap<>();
   class="kw">private class="kw">final class="kw">transient Map<UUID, PointManager.SelectionObserver> selectionObservers = new ConcurrentHashMap<>();
   @Nonnull
   class="kw">private class="kw">final PointSpatialIndex spatialIndex = new PointSpatialIndex();
   @Nullable
   class="kw">private World world;

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

   class="kw">private void postDecode() {
      for (Entry var2 : this.points.entrySet()) {
         var2.getValue().setId(var2.getKey());
         var2.getValue().expandTags();
      }

      this.spatialIndex.markDirty();
   }

   class="kw">public void register(@Nonnull String var1, @Nonnull PointEntry var2) {
      this.points.put(var1, var2);
      this.spatialIndex.markDirty();
   }

   class="kw">public void unregister(@Nonnull String var1) {
      this.points.remove(var1);
      this.spatialIndex.markDirty();
   }

   @Nullable
   class="kw">public PointEntry getPoint(@Nonnull String var1) {
      class="kw">return this.points.get(var1);
   }

   @Nonnull
   class="kw">public Collection<PointEntry> getPoints() {
      class="kw">return Collections.unmodifiableCollection(this.points.values());
   }

   @Nonnull
   class="kw">public Collection<PointEntry> getPointsWithTags(String... var1) {
      List var2 = Arrays.stream(var1).map(AssetRegistry::getOrCreateTagIndex).toList();
      ArrayList var3 = new ArrayList<>();

      for (PointEntry var5 : this.points.values()) {
         if (var5.hasTags(var2)) {
            var3.add(var5);
         }
      }

      class="kw">return var3;
   }

   @Nonnull
   class="kw">public Map<String, PointEntry> getPointsMap() {
      class="kw">return Collections.unmodifiableMap(this.points);
   }

   class="kw">public boolean hasPoint(@Nonnull String var1) {
      class="kw">return this.points.containsKey(var1);
   }

   class="kw">public void markSpatialDirty() {
      this.spatialIndex.markDirty();
   }

   class="kw">public void setWorld(@Nullable World var1) {
      this.world = var1;
   }

   @Nullable
   class="kw">public World getWorld() {
      class="kw">return this.world;
   }

   @Nonnull
   class="kw">public String generateUniquePointId() {
      ThreadLocalRandom var1 = ThreadLocalRandom.current();

      String var2;
      do {
         StringBuilder var3 = new StringBuilder("pt_");

         for (int var4 = 0; var4 < 6; var4++) {
            var3.append("abcdefghijklmnopqrstuvwxyz0123456789".charAt(var1.nextInt("abcdefghijklmnopqrstuvwxyz0123456789".length())));
         }

         var2 = var3.toString();
      } while (this.hasPoint(var2));

      class="kw">return var2;
   }

   @Nonnull
   class="kw">public List<PointEntry> queryRadius(@Nonnull Vector3d var1, double var2) {
      this.spatialIndex.rebuildIfDirty(this.points.values());
      ArrayList var4 = new ArrayList<>();
      this.spatialIndex.queryRadius(var1, var2, var4);
      class="kw">return var4;
   }

   @Nonnull
   class="kw">public List<PointEntry> queryRadius(@Nonnull Vector3d var1, double var2, int var4) {
      List var5 = this.queryRadius(var1, var2);
      var5.removeIf(var1x -> !var1x.hasTag(var4));
      class="kw">return var5;
   }

   @Nonnull
   class="kw">public List<PointEntry> queryRadius(@Nonnull Vector3d var1, double var2, @Nonnull String var4) {
      class="kw">return this.queryRadius(var1, var2, AssetRegistry.getOrCreateTagIndex(var4));
   }

   class="kw">public void queryRadius(@Nonnull Vector3d var1, double var2, @Nonnull List<PointEntry> var4) {
      var4.clear();
      this.spatialIndex.rebuildIfDirty(this.points.values());
      this.spatialIndex.queryRadius(var1, var2, var4);
   }

   class="kw">public void queryRadius(@Nonnull Vector3d var1, double var2, int var4, @Nonnull List<PointEntry> var5) {
      this.queryRadius(var1, var2, var5);
      var5.removeIf(var1x -> !var1x.hasTag(var4));
   }

   @Nonnull
   class="kw">public List<PointEntry> getPointsByTag(int var1) {
      ArrayList var2 = new ArrayList<>();

      for (PointEntry var4 : this.points.values()) {
         if (var4.hasTag(var1)) {
            var2.add(var4);
         }
      }

      class="kw">return var2;
   }

   class="kw">public boolean setTag(@Nonnull String var1, @Nonnull String var2, @Nullable String var3) {
      PointEntry var4 = this.points.get(var1);
      if (var4 == null) {
         class="kw">return false;
      }

      String var5 = var2.trim();
      if (var5.isEmpty()) {
         class="kw">return false;
      }

      LinkedHashMap var6 = new LinkedHashMap<>(var4.getRawTags());
      var6.put(var5, PointCodecs.normalizeValue(var3));
      var4.setTags(var6);
      class="kw">return true;
   }

   class="kw">public boolean removeTag(@Nonnull String var1, @Nonnull String var2) {
      PointEntry var3 = this.points.get(var1);
      if (var3 == null) {
         class="kw">return false;
      }

      String var4 = var2.trim();
      if (!var3.getRawTags().containsKey(var4)) {
         class="kw">return false;
      }

      LinkedHashMap var5 = new LinkedHashMap<>(var3.getRawTags());
      var5.remove(var4);
      var3.setTags(var5);
      class="kw">return true;
   }

   class="kw">public boolean isViewing(@Nonnull UUID var1) {
      EnumSet var2 = this.activeViewers.get(var1);
      class="kw">return var2 != null && !var2.isEmpty();
   }

   class="kw">public void addViewer(@Nonnull UUID var1, @Nonnull PointManager.ViewSource var2) {
      this.activeViewers.computeIfAbsent(var1, var0 -> EnumSet.noneOf(PointManager.ViewSource.class)).add(var2);
   }

   class="kw">public void removeViewer(@Nonnull UUID var1, @Nonnull PointManager.ViewSource var2) {
      this.activeViewers.computeIfPresent(var1, (var1x, var2x) -> {
         var2x.remove(var2);
         class="kw">return var2x.isEmpty() ? null : var2x;
      });
   }

   @Nonnull
   class="kw">public Set<UUID> getViewerUuids() {
      class="kw">return new HashSet<>(this.activeViewers.keySet());
   }

   class="kw">public void clearViewers() {
      this.activeViewers.clear();
      this.playerSelections.clear();
   }

   class="kw">public void setPlayerSelection(@Nonnull UUID var1, @Nullable String var2) {
      if (var2 == null) {
         this.playerSelections.remove(var1);
      } else {
         this.playerSelections.put(var1, var2);
      }

      PointManager.SelectionObserver var3 = this.selectionObservers.get(var1);
      if (var3 != null) {
         var3.onSelectionChanged(var2);
      }
   }

   @Nullable
   class="kw">public String getPlayerSelection(@Nonnull UUID var1) {
      class="kw">return this.playerSelections.get(var1);
   }

   class="kw">public void setSelectionObserver(@Nonnull UUID var1, @Nonnull PointManager.SelectionObserver var2) {
      this.selectionObservers.put(var1, var2);
   }

   class="kw">public void clearSelectionObserver(@Nonnull UUID var1, @Nonnull PointManager.SelectionObserver var2) {
      this.selectionObservers.remove(var1, var2);
   }

   class="kw">public void sendPointDisplay(@Nonnull PlayerRef var1) {
      var1.getPacketHandler().write(new UpdatePointDisplay(this.buildDisplayEntries()));
   }

   class="kw">public void notifyViewersAdd(@Nonnull PointEntry var1) {
      if (!this.activeViewers.isEmpty()) {
         AddOrUpdatePointDisplay var2 = new AddOrUpdatePointDisplay(var1.getId(), this.buildDisplayEntry(var1));

         for (UUID var4 : this.activeViewers.keySet()) {
            PlayerRef var5 = Universe.get().getPlayer(var4);
            if (var5 != null) {
               var5.getPacketHandler().write(var2);
            }
         }
      }
   }

   class="kw">public void notifyViewersRemove(@Nonnull String var1) {
      if (!this.activeViewers.isEmpty()) {
         RemovePointDisplay var2 = new RemovePointDisplay(var1);

         for (UUID var4 : this.activeViewers.keySet()) {
            PlayerRef var5 = Universe.get().getPlayer(var4);
            if (var5 != null) {
               var5.getPacketHandler().write(var2);
            }
         }
      }
   }

   @Nonnull
   class="kw">private PointDisplayEntry[] buildDisplayEntries() {
      Collection var1 = this.points.values();
      PointDisplayEntry[] var2 = new PointDisplayEntry[var1.size()];
      int var3 = 0;

      for (PointEntry var5 : var1) {
         var2[var3++] = this.buildDisplayEntry(var5);
      }

      class="kw">return var2;
   }

   @Nonnull
   class="kw">public PointDisplayEntry buildDisplayEntry(@Nonnull PointEntry var1) {
      PointDisplayEntry var2 = new PointDisplayEntry();
      Vector3d var3 = var1.getPosition();
      Vector3f var4 = var1.getRotation();
      var2.id = var1.getId();
      var2.name = var1.getName();
      var2.position = new Vector3f((float)var3.x(), (float)var3.y(), (float)var3.z());
      var2.rotation = new Vector3f(var4);
      var2.shape = var1.getShape();
      if (!var1.getRawTags().isEmpty()) {
         var2.tags = new LinkedHashMap<>(var1.getRawTags());
      }

      class="kw">return var2;
   }

   @Nonnull
   @Override
   class="kw">public Resource<EntityStore> clone() {
      throw new UnsupportedOperationException("PointManager cannot be cloned");
   }

   class="kw">public class="kw">interface SelectionObserver {
      void onSelectionChanged(@Nullable String var1);
   }

   class="kw">public enum ViewSource {
      TOOL;

      ViewSource() {
      }
   }
}