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

class="kw">import com.hypixel.hytale.builtin.hytalegenerator.graph.GraphSpace;
class="kw">import java.util.ArrayList;
class="kw">import java.util.List;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;

class="kw">public class OpposedToGraphEdgesVectorProvider class="kw">extends VectorProvider {
   @Nonnull
   class="kw">private class="kw">static class="kw">final Vector3d DEFAULT_VECTOR = new Vector3d(0.0, 1.0, 0.0);
   class="kw">private class="kw">static class="kw">final double EPSILON_SQUARED = 1.0E-12;
   @Nonnull
   class="kw">private class="kw">final List<Vector3d> rDirections = new ArrayList<>();
   @Nonnull
   class="kw">private class="kw">final Vector3d rCandidate = new Vector3d();
   @Nonnull
   class="kw">private class="kw">final Vector3d rBest = new Vector3d();
   class="kw">private int rDirectionCount;
   class="kw">private double rBestCost;

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

   @Override
   class="kw">public void process(@Nonnull VectorProvider.Context var1, @Nonnull Vector3d var2) {
      GraphSpace.Node var3 = var1.graphNode;
      if (var3 == null) {
         var2.set(DEFAULT_VECTOR);
      } else {
         this.rDirectionCount = 0;
         double var4 = var3.position().x();
         double var6 = var3.position().y();
         double var8 = var3.position().z();

         for (GraphSpace.Edge var11 : var3.edges()) {
            GraphSpace.Node var12 = var11.otherNode(var3);
            double var13 = var12.position().x() - var4;
            double var15 = var12.position().y() - var6;
            double var17 = var12.position().z() - var8;
            double var19 = var13 * var13 + var15 * var15 + var17 * var17;
            if (!(var19 < 1.0E-12)) {
               double var21 = 1.0 / Math.sqrt(var19);
               this.slot(this.rDirectionCount).set(var13 * var21, var15 * var21, var17 * var21);
               this.rDirectionCount++;
            }
         }

         if (this.rDirectionCount == 0) {
            var2.set(DEFAULT_VECTOR);
         } else {
            this.rBestCost = Double.POSITIVE_INFINITY;
            this.rBest.set(DEFAULT_VECTOR);

            for (int var40 = 0; var40 < this.rDirectionCount; var40++) {
               Vector3d var41 = this.rDirections.get(var40);
               this.tryCandidate(-var41.x, -var41.y, -var41.z);

               for (int var42 = var40 + 1; var42 < this.rDirectionCount; var42++) {
                  Vector3d var43 = this.rDirections.get(var42);
                  double var14 = var41.x + var43.x;
                  double var16 = var41.y + var43.y;
                  double var18 = var41.z + var43.z;
                  if (var14 * var14 + var16 * var16 + var18 * var18 < 1.0E-12) {
                     this.tryPerpendiculars(var41);
                  } else {
                     this.tryCandidate(-var14, -var16, -var18);
                  }

                  for (int var20 = var42 + 1; var20 < this.rDirectionCount; var20++) {
                     Vector3d var44 = this.rDirections.get(var20);
                     double var22 = var41.x - var43.x;
                     double var24 = var41.y - var43.y;
                     double var26 = var41.z - var43.z;
                     double var28 = var41.x - var44.x;
                     double var30 = var41.y - var44.y;
                     double var32 = var41.z - var44.z;
                     double var34 = var24 * var32 - var26 * var30;
                     double var36 = var26 * var28 - var22 * var32;
                     double var38 = var22 * var30 - var24 * var28;
                     this.tryCandidate(var34, var36, var38);
                     this.tryCandidate(-var34, -var36, -var38);
                  }
               }
            }

            var2.set(this.rBest);
         }
      }
   }

   class="kw">private void tryCandidate(double var1, double var3, double var5) {
      double var7 = var1 * var1 + var3 * var3 + var5 * var5;
      if (!(var7 < 1.0E-12)) {
         double var9 = 1.0 / Math.sqrt(var7);
         this.rCandidate.set(var1 * var9, var3 * var9, var5 * var9);
         double var11 = Double.NEGATIVE_INFINITY;

         for (int var13 = 0; var13 < this.rDirectionCount; var13++) {
            Vector3d var14 = this.rDirections.get(var13);
            double var15 = this.rCandidate.x * var14.x + this.rCandidate.y * var14.y + this.rCandidate.z * var14.z;
            if (var15 > var11) {
               var11 = var15;
            }
         }

         if (var11 < this.rBestCost) {
            this.rBestCost = var11;
            this.rBest.set(this.rCandidate);
         }
      }
   }

   class="kw">private void tryPerpendiculars(@Nonnull Vector3d var1) {
      double var2 = Math.abs(var1.x);
      double var4 = Math.abs(var1.y);
      double var6 = Math.abs(var1.z);
      double var8;
      double var10;
      double var12;
      if (var2 <= var4 && var2 <= var6) {
         var8 = 1.0;
         var10 = 0.0;
         var12 = 0.0;
      } else if (var4 <= var6) {
         var8 = 0.0;
         var10 = 1.0;
         var12 = 0.0;
      } else {
         var8 = 0.0;
         var10 = 0.0;
         var12 = 1.0;
      }

      double var14 = var1.y * var12 - var1.z * var10;
      double var16 = var1.z * var8 - var1.x * var12;
      double var18 = var1.x * var10 - var1.y * var8;
      this.tryCandidate(var14, var16, var18);
      this.tryCandidate(var1.y * var18 - var1.z * var16, var1.z * var14 - var1.x * var18, var1.x * var16 - var1.y * var14);
   }

   @Nonnull
   class="kw">private Vector3d slot(int var1) {
      if (var1 < this.rDirections.size()) {
         class="kw">return this.rDirections.get(var1);
      }

      Vector3d var2 = new Vector3d();
      this.rDirections.add(var2);
      class="kw">return var2;
   }
}