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

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.bounds.Bounds3d;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.pipe.Control;
class="kw">import com.hypixel.hytale.builtin.hytalegenerator.pipe.Pipe;
class="kw">import com.hypixel.hytale.component.spatial.KDTree;
class="kw">import com.hypixel.hytale.component.spatial.SpatialData;
class="kw">import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
class="kw">import it.unimi.dsi.fastutil.ints.IntSet;
class="kw">import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
class="kw">import it.unimi.dsi.fastutil.longs.Long2ObjectOpenHashMap;
class="kw">import java.util.ArrayList;
class="kw">import java.util.Collection;
class="kw">import java.util.Collections;
class="kw">import java.util.Comparator;
class="kw">import java.util.List;
class="kw">import java.util.Objects;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3dc;

class="kw">public class GraphSpace class="kw">implements IndexedGraphSpace {
   class="kw">private int nextId = 0;
   @Nonnull
   class="kw">private List<GraphSpace.Node> nodes = new ArrayList<>();
   @Nonnull
   class="kw">private List<GraphSpace.Node> unmodifiableNodes = Collections.unmodifiableList(this.nodes);
   @Nonnull
   class="kw">private class="kw">final Long2ObjectMap<GraphSpace.Edge> edges = new Long2ObjectOpenHashMap();
   @Nonnull
   class="kw">private class="kw">final List<Runnable> taskQueue = new ArrayList<>();
   @Nonnull
   class="kw">private class="kw">final KDTree<GraphSpace.Node> kdTree = new KDTree<>(var0 -> true);
   @Nonnull
   class="kw">private class="kw">final SpatialData<GraphSpace.Node> spacialData = new SpatialData<>();
   class="kw">private class="kw">volatile boolean dirty = true;

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

   @Override
   class="kw">public void getNodes(@Nonnull Bounds3d var1, @Nonnull List<GraphSpace.Node> var2) {
      this.rebuildIfDirty();
      this.kdTree.collectBox(var1.min, var1.max, var2);
   }

   @Override
   class="kw">public void getNodes(@Nonnull Vector3dc var1, double var2, @Nonnull List<GraphSpace.Node> var4) {
      this.rebuildIfDirty();
      this.kdTree.collect(var1, Math.nextDown(var2), var4);
   }

   @Nonnull
   class="kw">public List<GraphSpace.Node> getNodes() {
      class="kw">return this.unmodifiableNodes;
   }

   @Nonnull
   class="kw">public Collection<GraphSpace.Edge> getEdges() {
      class="kw">return this.edges.values();
   }

   class="kw">public void trim(@Nonnull Bounds3d var1) {
      List var2 = new ArrayList<>(this.nodes.size());

      for (GraphSpace.Node var4 : this.nodes) {
         if (var1.contains(var4.position)) {
            var2.add(var4);
         } else {
            var4.discard();
            this.dirty = true;
         }
      }

      this.nodes = var2;
      this.unmodifiableNodes = Collections.unmodifiableList(this.nodes);
   }

   class="kw">public void schedule(@Nonnull Runnable var1) {
      this.taskQueue.add(var1);
   }

   class="kw">public void scheduleNodeCreation(@Nonnull Vector3d var1) {
      this.taskQueue.add(() -> this.createNode(var1));
   }

   class="kw">public void scheduleEdgeCreation(@Nonnull GraphSpace.Node var1, @Nonnull GraphSpace.Node var2) {
      this.taskQueue.add(() -> this.getOrCreateEdge(var1, var2));
   }

   class="kw">public void scheduleMoveNode(@Nonnull GraphSpace.Node var1, @Nonnull Vector3dc var2) {
      this.taskQueue.add(() -> this.moveNode(var1, var2));
   }

   class="kw">public void scheduleNodeDeletion(@Nonnull GraphSpace.Node var1) {
      assert var1.graphSpace == this;
      this.taskQueue.add(() -> this.deleteNode(var1));
   }

   class="kw">public void scheduleEdgeDeletion(@Nonnull GraphSpace.Node var1, @Nonnull GraphSpace.Node var2) {
      long var3 = GraphSpace.Edge.createId(var1, var2);
      GraphSpace.Edge var5 = (GraphSpace.Edge)this.edges.get(var3);
      if (var5 != null) {
         this.scheduleEdgeDeletion(var5);
      }
   }

   class="kw">public void scheduleEdgeDeletion(@Nonnull GraphSpace.Edge var1) {
      this.taskQueue.add(() -> this.deleteEdge(var1));
   }

   @Nonnull
   class="kw">public GraphSpace.Node createNode(@Nonnull Vector3d var1) {
      GraphSpace.Node var2 = new GraphSpace.Node(this, this.nextId++);
      var2.move(var1);
      this.nodes.add(var2);
      this.dirty = true;
      class="kw">return var2;
   }

   @Nullable
   class="kw">public GraphSpace.Edge getOrCreateEdge(@Nonnull GraphSpace.Node var1, @Nonnull GraphSpace.Node var2) {
      if (!var1.isDiscarded() && !var2.isDiscarded()) {
         assert var1.graphSpace == this && var2.graphSpace == this;
         assert var1.id != var2.id;
         GraphSpace.Edge var3 = (GraphSpace.Edge)this.edges.get(GraphSpace.Edge.createId(var1, var2));
         if (var3 != null) {
            class="kw">return var3;
         }

         var3 = new GraphSpace.Edge(var1, var2);
         this.edges.put(var3.id, var3);
         var1.edges.add(var3);
         var2.edges.add(var3);
         class="kw">return var3;
      } else {
         class="kw">return null;
      }
   }

   class="kw">public void moveNode(@Nonnull GraphSpace.Node var1, @Nonnull Vector3dc var2) {
      var1.move(var2);
      this.dirty = true;
   }

   @Nullable
   class="kw">public GraphSpace.Edge getEdge(@Nonnull GraphSpace.Node var1, @Nonnull GraphSpace.Node var2) {
      assert var1.graphSpace == this && var2.graphSpace == this;
      assert var1.id != var2.id;
      class="kw">return (GraphSpace.Edge)this.edges.get(GraphSpace.Edge.createId(var1, var2));
   }

   class="kw">public void deleteNode(@Nonnull GraphSpace.Node var1) {
      assert var1.isParentSpace(this);
      this.nodes.remove(var1);
      var1.discard();
      this.dirty = true;
   }

   class="kw">public void deleteEdge(@Nonnull GraphSpace.Node var1, @Nonnull GraphSpace.Node var2) {
      long var3 = GraphSpace.Edge.createId(var1, var2);
      GraphSpace.Edge var5 = (GraphSpace.Edge)this.edges.get(var3);
      if (var5 != null) {
         var5.nodeA.edges.remove(var5);
         var5.nodeB.edges.remove(var5);
         this.edges.remove(var5.id);
      }
   }

   class="kw">public void deleteEdge(@Nonnull GraphSpace.Edge var1) {
      var1 = (GraphSpace.Edge)this.edges.get(var1.id);
      if (var1 != null) {
         var1.nodeA.edges.remove(var1);
         var1.nodeB.edges.remove(var1);
         this.edges.remove(var1.id);
      }
   }

   class="kw">public void processTaskQueue() {
      for (Runnable var2 : this.taskQueue) {
         var2.run();
      }

      this.taskQueue.clear();
      this.dirty = true;
   }

   class="kw">private void rebuildIfDirty() {
      if (this.dirty) {
         this.dirty = false;
         this.spacialData.clear();
         this.spacialData.addCapacity(this.nodes.size());

         for (GraphSpace.Node var2 : this.nodes) {
            this.spacialData.append(var2.position, var2);
         }

         this.kdTree.rebuild(this.spacialData);
      }
   }

   @Nonnull
   class="kw">public GraphSpace.ReadOnly toReadOnly() {
      this.rebuildIfDirty();
      class="kw">return new GraphSpace.ReadOnly(this.kdTree);
   }

   class="kw">public class="kw">static class Content {
      class="kw">public class="kw">static class="kw">final int DEFAULT_TAG = toIntId("");
      class="kw">public class="kw">static class="kw">final int VOID_INDEX = -1;
      @Nonnull
      class="kw">public class="kw">static class="kw">final GraphSpace.Content DEFAULT = new GraphSpace.Content(new int[]{DEFAULT_TAG}, -1);
      @Nonnull
      class="kw">public class="kw">final IntSet tagSet;
      class="kw">public class="kw">final int index;
      class="kw">private class="kw">final int hashCode;

      class="kw">public Content(@Nonnull int[] var1, int var2) {
         this.tagSet = new IntOpenHashSet(var1);
         this.index = var2;
         this.hashCode = Objects.hash(this.tagSet, var2);
      }

      class="kw">public class="kw">static int toIntId(@Nonnull String var0) {
         class="kw">return var0.hashCode();
      }

      @Override
      class="kw">public int hashCode() {
         class="kw">return this.hashCode;
      }
   }

   class="kw">public class="kw">static class Edge {
      class="kw">private class="kw">final long id;
      class="kw">private class="kw">final int hashCode;
      @Nonnull
      class="kw">private class="kw">final GraphSpace.Node nodeA;
      @Nonnull
      class="kw">private class="kw">final GraphSpace.Node nodeB;

      class="kw">private Edge(@Nonnull GraphSpace.Node var1, @Nonnull GraphSpace.Node var2) {
         assert var1.graphSpace == var2.graphSpace;
         assert var1.id != var2.id;
         GraphSpace.OrderedNodePair var3 = new GraphSpace.OrderedNodePair(var1, var2);
         this.nodeA = var3.lowNode;
         this.nodeB = var3.highNode;
         this.id = createId(var1, var2);
         this.hashCode = Objects.hash(this.id);
      }

      class="kw">public class="kw">static long createId(@Nonnull GraphSpace.Node var0, @Nonnull GraphSpace.Node var1) {
         int var2 = Math.max(var0.id, var1.id);
         int var3 = Math.min(var0.id, var1.id);
         class="kw">return var3 & 4294967295L | (long)var2 << 32;
      }

      class="kw">public long id() {
         class="kw">return this.id;
      }

      @Nonnull
      class="kw">public GraphSpace.Node nodeA() {
         class="kw">return this.nodeA;
      }

      @Nonnull
      class="kw">public GraphSpace.Node nodeB() {
         class="kw">return this.nodeB;
      }

      @Nonnull
      class="kw">public GraphSpace.Node otherNode(@Nonnull GraphSpace.Node var1) {
         assert this.nodeA == var1 || this.nodeB == var1;
         class="kw">return this.nodeA == var1 ? this.nodeB : this.nodeA;
      }

      @Override
      class="kw">public boolean equals(@Nullable Object var1) {
         class="kw">return var1 class="kw">instanceof GraphSpace.Edge var2 ? this.id == var2.id : false;
      }

      @Override
      class="kw">public int hashCode() {
         class="kw">return this.hashCode;
      }
   }

   class="kw">public class="kw">static class Node {
      class="kw">public class="kw">static class="kw">final int VOID_ID = -1;
      @Nonnull
      class="kw">public class="kw">static class="kw">final Comparator<GraphSpace.Node> DETERMINISTIC_ORDER = GraphSpace.Node::compareDeterministic;
      class="kw">private class="kw">final int id;
      class="kw">private int hashCode;
      class="kw">private boolean isHashCodeDirty;
      @Nonnull
      class="kw">private class="kw">final Vector3d position;
      @Nullable
      class="kw">private GraphSpace graphSpace;
      @Nonnull
      class="kw">private class="kw">final List<GraphSpace.Edge> edges;
      @Nonnull
      class="kw">private GraphSpace.Content content;

      class="kw">private class="kw">static int compareDeterministic(@Nonnull GraphSpace.Node var0, @Nonnull GraphSpace.Node var1) {
         int var2 = Double.compare(var0.position.x, var1.position.x);
         if (var2 != 0) {
            class="kw">return var2;
         }

         var2 = Double.compare(var0.position.y, var1.position.y);
         if (var2 != 0) {
            class="kw">return var2;
         }

         var2 = Double.compare(var0.position.z, var1.position.z);
         class="kw">return var2 != 0 ? var2 : Integer.compare(var0.content.hashCode(), var1.content.hashCode());
      }

      class="kw">private Node(@Nonnull GraphSpace var1, int var2) {
         this.id = var2;
         this.hashCode = 0;
         this.isHashCodeDirty = true;
         this.graphSpace = var1;
         this.position = new Vector3d();
         this.edges = new ArrayList<>(2);
         this.content = GraphSpace.Content.DEFAULT;
      }

      class="kw">public int id() {
         class="kw">return this.id;
      }

      @Override
      class="kw">public int hashCode() {
         if (this.isHashCodeDirty) {
            this.hashCode = Objects.hash(this.position, this.content);
            this.isHashCodeDirty = false;
         }

         class="kw">return this.hashCode;
      }

      @Nonnull
      class="kw">public GraphSpace.Content content() {
         class="kw">return this.content;
      }

      @Nonnull
      class="kw">public Vector3dc position() {
         class="kw">return this.position;
      }

      @Nonnull
      class="kw">public List<GraphSpace.Edge> edges() {
         class="kw">return this.edges;
      }

      class="kw">public void viewConnections(@Nonnull Pipe.One<GraphSpace.Edge> var1) {
         Control var2 = new Control();

         for (GraphSpace.Edge var4 : this.edges) {
            if (var2.stop) {
               class="kw">return;
            }

            var1.accept(var4, var2);
         }
      }

      class="kw">public boolean isConnected(@Nonnull GraphSpace.Node var1) {
         if (var1.graphSpace != this.graphSpace) {
            class="kw">return false;
         }

         for (GraphSpace.Edge var3 : this.edges) {
            if (var3.otherNode(this).id == var1.id) {
               class="kw">return true;
            }
         }

         class="kw">return false;
      }

      class="kw">public boolean isDiscarded() {
         class="kw">return this.graphSpace == null;
      }

      class="kw">public boolean isParentSpace(@Nonnull GraphSpace var1) {
         class="kw">return this.graphSpace == var1;
      }

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

      class="kw">public void setContent(@Nonnull GraphSpace.Content var1) {
         this.content = var1;
         this.isHashCodeDirty = true;
      }

      class="kw">public void move(@Nonnull Vector3dc var1) {
         this.position.set(var1);
         this.isHashCodeDirty = true;
      }

      class="kw">public void disconnectAll() {
         assert this.graphSpace != null;

         for (GraphSpace.Edge var2 : this.edges) {
            this.graphSpace.edges.remove(var2.id);
            var2.otherNode(this).edges.remove(var2);
         }

         this.edges.clear();
      }

      class="kw">private void discard() {
         this.disconnectAll();
         this.graphSpace = null;
      }
   }

   class="kw">public class="kw">static class OrderedNodePair {
      @Nonnull
      class="kw">public GraphSpace.Node highNode;
      @Nonnull
      class="kw">public GraphSpace.Node lowNode;

      class="kw">public OrderedNodePair(@Nonnull GraphSpace.Node var1, @Nonnull GraphSpace.Node var2) {
         assert var1 != var2 && var1.graphSpace == var2.graphSpace;
         if (var1.id > var2.id) {
            this.highNode = var1;
            this.lowNode = var2;
         } else {
            this.highNode = var2;
            this.lowNode = var1;
         }
      }
   }

   class="kw">public class="kw">static class ReadOnly class="kw">implements IndexedGraphSpace {
      @Nonnull
      class="kw">private class="kw">final KDTree<GraphSpace.Node> kdTree;

      class="kw">private ReadOnly(@Nonnull KDTree<GraphSpace.Node> var1) {
         this.kdTree = var1;
      }

      @Override
      class="kw">public void getNodes(@Nonnull Bounds3d var1, @Nonnull List<GraphSpace.Node> var2) {
         this.kdTree.collectBox(var1.min, var1.max, var2);
      }

      @Override
      class="kw">public void getNodes(@Nonnull Vector3dc var1, double var2, @Nonnull List<GraphSpace.Node> var4) {
         this.kdTree.collect(var1, Math.nextDown(var2), var4);
      }
   }
}