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

class="kw">import com.hypixel.hytale.builtin.adventure.wilderness.WildernessConfig;
class="kw">import com.hypixel.hytale.builtin.adventure.wilderness.WildernessPlugin;
class="kw">import com.hypixel.hytale.component.Resource;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.function.function.TriFunction;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import java.util.Collection;
class="kw">import java.util.Map;
class="kw">import java.util.Queue;
class="kw">import java.util.concurrent.ArrayBlockingQueue;
class="kw">import java.util.concurrent.ConcurrentHashMap;
class="kw">import java.util.concurrent.atomic.AtomicLong;
class="kw">import java.util.function.BiFunction;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class WildernessTracker class="kw">implements Resource<ChunkStore> {
   class="kw">protected class="kw">static class="kw">final int VECTOR_POOL_CAPACITY = 1000;
   class="kw">protected class="kw">final boolean enabled;
   class="kw">protected class="kw">final int ownedChunkRadius;
   class="kw">protected class="kw">final int ownedChunkRadiusY;
   class="kw">protected class="kw">final int unownedChunkRadius;
   class="kw">protected class="kw">final int unownedChunkRadiusY;
   class="kw">protected class="kw">final AtomicLong generation = new AtomicLong();
   class="kw">protected class="kw">final Map<Vector3i, WildernessTracker.Counter> homeChunks = new ConcurrentHashMap<>();
   class="kw">protected class="kw">final Queue<Vector3i> vecPool = new ArrayBlockingQueue<>(1000);

   class="kw">public WildernessTracker() {
      this.enabled = false;
      this.ownedChunkRadius = 8;
      this.ownedChunkRadiusY = 2;
      this.unownedChunkRadius = 2;
      this.unownedChunkRadiusY = 1;
   }

   class="kw">public WildernessTracker(@Nonnull WildernessConfig var1) {
      this.enabled = var1.isEnabled();
      this.ownedChunkRadius = var1.getOwnedHomeChunkRadius();
      this.ownedChunkRadiusY = var1.getOwnedHomeChunkRadiusY();
      this.unownedChunkRadius = var1.getUnownedHomeChunkRadius();
      this.unownedChunkRadiusY = var1.getUnownedHomeChunkRadiusY();
   }

   class="kw">public WildernessTracker(@Nonnull WildernessTracker var1) {
      this.enabled = var1.enabled;
      this.ownedChunkRadius = var1.ownedChunkRadius;
      this.ownedChunkRadiusY = var1.ownedChunkRadiusY;
      this.unownedChunkRadius = var1.unownedChunkRadius;
      this.unownedChunkRadiusY = var1.unownedChunkRadiusY;
      this.homeChunks.putAll(var1.homeChunks);
   }

   @Nonnull
   class="kw">public WildernessTracker clone() {
      class="kw">return new WildernessTracker(this);
   }

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

   class="kw">public boolean isEnabled() {
      class="kw">return this.enabled;
   }

   class="kw">public boolean isDisabled() {
      class="kw">return !this.enabled;
   }

   class="kw">public boolean isHome(@Nonnull Vector3i var1) {
      class="kw">return !this.isWilderness(var1);
   }

   class="kw">public boolean isHome(@Nonnull Vector3d var1) {
      class="kw">return !this.isWilderness(var1);
   }

   class="kw">public boolean isHome(int var1, int var2, int var3) {
      class="kw">return !this.isWilderness(var1, var2, var3);
   }

   class="kw">public boolean isWilderness(@Nonnull Vector3i var1) {
      int var2 = var1.x;
      int var3 = var1.y;
      int var4 = var1.z;
      class="kw">return this.isWilderness(var2, var3, var4);
   }

   class="kw">public boolean isWilderness(@Nonnull Vector3d var1) {
      int var2 = MathUtil.floor(var1.x);
      int var3 = MathUtil.floor(var1.y);
      int var4 = MathUtil.floor(var1.z);
      class="kw">return this.isWilderness(var2, var3, var4);
   }

   class="kw">public boolean isWilderness(int var1, int var2, int var3) {
      Vector3i var4 = this.newVector();

      try {
         var4.x = ChunkUtil.chunkCoordinate(var1);
         var4.y = ChunkUtil.chunkCoordinate(var2);
         var4.z = ChunkUtil.chunkCoordinate(var3);
         class="kw">return !this.homeChunks.containsKey(var4);
      } class="kw">finally {
         this.recycle(var4);
      }
   }

   class="kw">public boolean isWildernessChunk(int var1, int var2, int var3) {
      Vector3i var4 = this.newVector();

      try {
         var4.x = var1;
         var4.y = var2;
         var4.z = var3;
         class="kw">return !this.homeChunks.containsKey(var4);
      } class="kw">finally {
         this.recycle(var4);
      }
   }

   class="kw">public boolean isWildernessChunk(@Nonnull Vector3i var1) {
      class="kw">return !this.homeChunks.containsKey(var1);
   }

   class="kw">public void collectHomeChunks(@Nonnull Vector3i var1, int var2, int var3, int var4, @Nonnull Collection<Vector3i> var5) {
      int var6 = var1.x;
      int var7 = var1.y;
      int var8 = var1.z;
      this.collectHomeChunks(var6, var7, var8, var2, var3, var4, var5);
   }

   class="kw">public void collectHomeChunks(@Nonnull Vector3d var1, int var2, int var3, int var4, @Nonnull Collection<Vector3i> var5) {
      int var6 = MathUtil.floor(var1.x);
      int var7 = MathUtil.floor(var1.y);
      int var8 = MathUtil.floor(var1.z);
      this.collectHomeChunks(var6, var7, var8, var2, var3, var4, var5);
   }

   class="kw">public void collectWildernessChunks(@Nonnull Vector3i var1, int var2, int var3, int var4, @Nonnull Collection<Vector3i> var5) {
      int var6 = var1.x;
      int var7 = var1.y;
      int var8 = var1.z;
      this.collectWildernessChunks(var6, var7, var8, var2, var3, var4, var5);
   }

   class="kw">public void collectWildernessChunks(@Nonnull Vector3d var1, int var2, int var3, int var4, @Nonnull Collection<Vector3i> var5) {
      int var6 = MathUtil.floor(var1.x);
      int var7 = MathUtil.floor(var1.y);
      int var8 = MathUtil.floor(var1.z);
      this.collectWildernessChunks(var6, var7, var8, var2, var3, var4, var5);
   }

   class="kw">public void collectHomeChunks(int var1, int var2, int var3, int var4, int var5, int var6, @Nonnull Collection<Vector3i> var7) {
      int var8 = ChunkUtil.chunkCoordinate(var1);
      int var9 = ChunkUtil.chunkCoordinate(var2);
      int var10 = ChunkUtil.chunkCoordinate(var3);
      int var11 = ChunkUtil.chunkCoordinate(var4);
      int var12 = ChunkUtil.chunkCoordinate(var5);
      int var13 = ChunkUtil.chunkCoordinate(var6);
      iterate(this, var8, var9, var10, var11, var12, var13, var7, (var0, var1x, var2x) -> {
         if (var0.homeChunks.containsKey(var1x)) {
            var2x.add(new Vector3i(var1x));
         }

         class="kw">return WildernessTracker.Iterator.CONTINUE;
      });
   }

   class="kw">public void collectWildernessChunks(int var1, int var2, int var3, int var4, int var5, int var6, @Nonnull Collection<Vector3i> var7) {
      int var8 = ChunkUtil.chunkCoordinate(var1);
      int var9 = ChunkUtil.chunkCoordinate(var2);
      int var10 = ChunkUtil.chunkCoordinate(var3);
      int var11 = ChunkUtil.chunkCoordinate(var4);
      int var12 = ChunkUtil.chunkCoordinate(var5);
      int var13 = ChunkUtil.chunkCoordinate(var6);
      iterate(this, var8, var9, var10, var11, var12, var13, var7, (var0, var1x, var2x) -> {
         if (!var0.homeChunks.containsKey(var1x)) {
            var2x.add(new Vector3i(var1x));
         }

         class="kw">return WildernessTracker.Iterator.CONTINUE;
      });
   }

   class="kw">public void addHomeChunk(int var1, int var2, int var3, boolean var4) {
      int var5 = var4 ? this.ownedChunkRadius : this.unownedChunkRadius;
      int var6 = var4 ? this.ownedChunkRadiusY : this.unownedChunkRadiusY;
      if (var5 != -1 && var6 != -1) {
         iterate(
            this,
            var1,
            var2,
            var3,
            var5,
            var6,
            var5,
            null,
            (var0, var1x, var2x) -> var0.homeChunks.compute(var1x, WildernessTracker.Counter::increment).coords == var1x
               ? WildernessTracker.Iterator.CONSUME
               : WildernessTracker.Iterator.CONTINUE
         );
         this.generation.incrementAndGet();
      }
   }

   class="kw">public void removeHomeChunk(int var1, int var2, int var3, boolean var4) {
      int var5 = var4 ? this.ownedChunkRadius : this.unownedChunkRadius;
      int var6 = var4 ? this.ownedChunkRadiusY : this.unownedChunkRadiusY;
      if (var5 != -1 && var6 != -1) {
         WildernessTracker.Recycler var7 = WildernessTracker.Recycler.RESOURCE.get();
         iterate(this, var1, var2, var3, var5, var6, var5, var7, (var1x, var2x, var3x) -> {
            var1x.homeChunks.compute(var2x, var3x);
            if (var3x.removed != null) {
               this.recycle(var3x.removed);
               var3x.removed = null;
            }

            class="kw">return WildernessTracker.Iterator.CONTINUE;
         });
         this.generation.incrementAndGet();
      }
   }

   class="kw">protected class="kw">static <T> void iterate(
      @Nonnull WildernessTracker var0,
      int var1,
      int var2,
      int var3,
      int var4,
      int var5,
      int var6,
      @Nullable T var7,
      @Nonnull TriFunction<WildernessTracker, Vector3i, T, WildernessTracker.Iterator> var8
   ) {
      Vector3i var9 = var0.newVector();

      try {
         double var10 = 1.0 / (var4 * var4);
         double var12 = 1.0 / (var5 * var5);
         double var14 = 1.0 / (var6 * var6);

         for (int var16 = -var5; var16 <= var5; var16++) {
            double var17 = var16 * var16 * var12;

            for (int var19 = -var6; var19 <= var6; var19++) {
               double var20 = var19 * var19 * var14;

               for (int var22 = -var4; var22 <= var4; var22++) {
                  double var23 = var22 * var22 * var10;
                  if (!(var23 + var17 + var20 > 1.0)) {
                     var9.set(var1 + var22, var2 + var16, var3 + var19);
                     class="kw">switch ((WildernessTracker.Iterator)var8.apply(var0, var9, var7)) {
                        case CONTINUE:
                        class="kw">default:
                           break;
                        case CONSUME:
                           var9 = var0.newVector();
                           break;
                        case EXIT:
                           class="kw">return;
                     }
                  }
               }
            }
         }
      } class="kw">finally {
         var0.recycle(var9);
      }
   }

   @Nonnull
   class="kw">protected Vector3i newVector() {
      Vector3i var1 = this.vecPool.poll();
      class="kw">return var1 != null ? var1 : new Vector3i();
   }

   class="kw">protected void recycle(@Nonnull Vector3i var1) {
      this.vecPool.offer(var1);
   }

   class="kw">public class="kw">static ResourceType<ChunkStore, WildernessTracker> getResourceType() {
      class="kw">return WildernessPlugin.get().getWildernessTrackerResourceType();
   }

   @Nonnull
   class="kw">public class="kw">static WildernessTracker getTracker(@Nonnull World var0) {
      class="kw">return var0.getChunkStore().getStore().getResource(getResourceType());
   }

   class="kw">protected class="kw">static class Counter {
      @Nonnull
      class="kw">private class="kw">final Vector3i coords;
      class="kw">private int count = 0;

      class="kw">protected Counter(@Nonnull Vector3i var1) {
         this.coords = var1;
      }

      @Nonnull
      class="kw">protected class="kw">static WildernessTracker.Counter increment(@Nonnull Vector3i var0, @Nullable WildernessTracker.Counter var1) {
         var1 = var1 != null ? var1 : new WildernessTracker.Counter(var0);
         var1.count++;
         class="kw">return var1;
      }

      @Nullable
      class="kw">protected class="kw">static WildernessTracker.Counter decrement(@Nonnull Vector3i var0, @Nullable WildernessTracker.Counter var1) {
         class="kw">return var1 != null && --var1.count == 0 ? null : var1;
      }
   }

   class="kw">protected enum Iterator {
      CONTINUE,
      CONSUME,
      EXIT;

      Iterator() {
      }
   }

   class="kw">protected class="kw">static class Recycler class="kw">implements BiFunction<Vector3i, WildernessTracker.Counter, WildernessTracker.Counter> {
      class="kw">protected class="kw">static class="kw">final ThreadLocal<WildernessTracker.Recycler> RESOURCE = ThreadLocal.withInitial(WildernessTracker.Recycler::new);
      @Nullable
      class="kw">protected Vector3i removed;

      class="kw">protected Recycler() {
      }

      @Nullable
      class="kw">public WildernessTracker.Counter apply(@Nonnull Vector3i var1, @Nullable WildernessTracker.Counter var2) {
         if (WildernessTracker.Counter.decrement(var1, var2) == null && var2 != null) {
            this.removed = var2.coords;
            class="kw">return null;
         } else {
            class="kw">return var2;
         }
      }
   }
}