class="kw">package com.hypixel.hytale.common.collection;

class="kw">import it.unimi.dsi.fastutil.ints.IntArrayList;
class="kw">import it.unimi.dsi.fastutil.ints.IntArrays;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrays;
class="kw">import java.util.Comparator;
class="kw">import java.util.function.IntFunction;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class BucketList<E> {
   class="kw">public class="kw">static class="kw">final int INITIAL_BUCKET_ITEM_ARRAY_SIZE = 4;
   class="kw">public class="kw">static class="kw">final Comparator<BucketItem<?>> CLOSER_TO_SELF = Comparator.comparingDouble(var0 -> var0.squaredDistance);
   class="kw">protected class="kw">static class="kw">final byte[] EMPTY_INDICES = new byte[]{-1};
   class="kw">protected BucketItemPool<E> bucketItemPool;
   @Nullable
   class="kw">protected BucketList.Bucket<E>[] buckets;
   class="kw">protected byte[] bucketIndices = EMPTY_INDICES;
   class="kw">protected int bucketCount;
   class="kw">protected int squaredMaxDistance;

   class="kw">public BucketList(BucketItemPool<E> var1) {
      this.bucketItemPool = var1;
   }

   class="kw">public void setBucketItemPool(@Nonnull BucketItemPool<E> var1) {
      this.clear();
      this.bucketItemPool = var1;
   }

   class="kw">public void clear() {
      if (this.buckets != null && this.bucketItemPool != null) {
         for (BucketList.Bucket var4 : this.buckets) {
            var4.clear(this.bucketItemPool);
         }
      }
   }

   class="kw">public void reset() {
      this.clear();
      this.buckets = null;
      this.bucketCount = 0;
      this.bucketIndices = EMPTY_INDICES;
   }

   class="kw">public void configure(@Nonnull int[] var1) {
      this.configure(var1, 4);
   }

   class="kw">public void configure(@Nonnull int[] var1, int var2) {
      if (var1 == null) {
         throw new IllegalArgumentException("bucketRanges can't be null");
      }

      if (var1.length <= 0) {
         throw new IllegalArgumentException("bucketRanges can't beempty");
      }

      int[] var3 = (int[])var1.clone();
      IntArrays.quickSort(var3);
      if (var3[0] <= 0) {
         throw new IllegalArgumentException("bucketRanges entries must be >0");
      }

      this.configureWithPreSortedArray(var3, var2);
   }

   class="kw">public void configureWithPreSortedArray(@Nonnull int[] var1) {
      this.configureWithPreSortedArray(var1, 4);
   }

   class="kw">public void configureWithPreSortedArray(@Nonnull int[] var1, int var2) {
      this.clear();
      this.bucketCount = var1.length;
      this.squaredMaxDistance = var1[this.bucketCount - 1];
      this.squaredMaxDistance = this.squaredMaxDistance * this.squaredMaxDistance;
      this.buckets = new BucketList.Bucket[this.bucketCount];
      this.bucketIndices = new byte[this.squaredMaxDistance + 1];
      int var3 = 0;

      for (int var4 = 0; var4 < this.bucketCount; var4++) {
         int var5 = var1[var4] * var1[var4];
         this.buckets[var4] = new BucketList.Bucket<>(var2);

         for (int var6 = var3; var6 < var5; var6++) {
            this.bucketIndices[var6] = (byte)var4;
         }

         var3 = var5;
      }

      this.bucketIndices[this.bucketIndices.length - 1] = -1;
   }

   class="kw">public void configureWithPresortedArray(@Nonnull IntArrayList var1, int var2) {
      this.configureWithPreSortedArray(var1.toIntArray(), var2);
   }

   class="kw">public boolean add(@Nonnull E var1, double var2) {
      int var4 = this.getFirstBucketIndex((int)var2);
      if (var4 < 0) {
         class="kw">return false;
      }

      BucketItem var5 = this.bucketItemPool.allocate(var1, var2);
      this.buckets[var4].add(var5);
      class="kw">return true;
   }

   class="kw">public int getBucketCount() {
      class="kw">return this.buckets != null ? this.buckets.length : 0;
   }

   @Nullable
   class="kw">public BucketList.Bucket<E> getBucket(int var1) {
      class="kw">return var1 >= 0 && var1 < this.getBucketCount() ? this.buckets[var1] : null;
   }

   class="kw">public int getFirstBucketIndex(int var1) {
      if (var1 == 0) {
         class="kw">return this.bucketIndices[0];
      }

      var1 = Math.min(var1, this.squaredMaxDistance);
      class="kw">return var1 <= 0 ? -1 : this.bucketIndices[var1];
   }

   class="kw">public int getLastBucketIndex(int var1) {
      int var2 = Math.min(var1, this.squaredMaxDistance) - 1;
      class="kw">return var2 < 0 ? -1 : this.bucketIndices[var2];
   }

   @Nullable
   class="kw">public E getClosestInRange(int var1, int var2, @Nonnull Predicate<E> var3, @Nonnull BucketList.SortBufferProvider var4) {
      int var5 = var1 * var1;
      int var6 = this.getFirstBucketIndex(var5);
      if (var6 < 0) {
         class="kw">return null;
      }

      int var7 = var2 * var2;
      int var8 = this.getLastBucketIndex(var7);

      for (int var9 = var6; var9 <= var8; var9++) {
         BucketList.Bucket var10 = this.buckets[var9];
         if (!var10.isEmpty) {
            if (var10.isUnsorted) {
               var10.sort(var4);
            }

            BucketItem[] var11 = var10.bucketItems;
            int var12 = 0;

            for (int var13 = var10.size; var12 < var13; var12++) {
               BucketItem var14 = var11[var12];
               double var15 = var14.squaredDistance;
               if (!(var15 < var5)) {
                  if (var15 >= var7) {
                     class="kw">return null;
                  }

                  Object var17 = var14.item;
                  if (var17 != null && var3.test(var17)) {
                     class="kw">return var17;
                  }
               }
            }
         }
      }

      class="kw">return null;
   }

   class="kw">public class="kw">static void addBucketDistance(@Nonnull IntArrayList var0, int var1, int var2) {
      addBucketDistance(var0, var1, var2, -1);
   }

   class="kw">public class="kw">static void addBucketDistance(@Nonnull IntArrayList var0, int var1, int var2, int var3) {
      if (var2 >= 1) {
         int var4 = 0;

         int var5;
         for (var5 = var0.size(); var4 < var5; var4++) {
            int var6 = var0.getInt(var4);
            if (var6 == var2) {
               class="kw">return;
            }

            if (var6 > var2) {
               break;
            }
         }

         var0.add(var4, var2);
         if (++var5 > var1) {
            int var15 = var0.getInt(0);
            int var7 = area(0, var15);
            int var8 = Integer.MAX_VALUE;
            int var9 = -1;

            for (int var13 = 1; var13 < var5; var13++) {
               int var10 = var0.getInt(var13);
               int var11 = area(var15, var10);
               int var12 = var7 + var11;
               if (var12 <= var8 && var15 != var3) {
                  var9 = var13 - 1;
                  var8 = var12;
               }

               var15 = var10;
               var7 = var11;
            }

            var0.removeInt(var9);
         }
      }
   }

   class="kw">protected class="kw">static int area(int var0, int var1) {
      class="kw">return var1 * var1 - var0 * var0;
   }

   class="kw">public class="kw">static class Bucket<E> {
      class="kw">protected BucketItem<E>[] bucketItems;
      class="kw">protected int size;
      class="kw">protected boolean isUnsorted;
      class="kw">protected boolean isEmpty;

      class="kw">public Bucket(int var1) {
         this.bucketItems = new BucketItem[var1];
         this.size = 0;
         this.isUnsorted = false;
         this.isEmpty = true;
      }

      class="kw">public BucketItem<E>[] getItems() {
         class="kw">return this.bucketItems;
      }

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

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

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

      class="kw">public void clear(@Nonnull BucketItemPool<E> var1) {
         if (!this.isEmpty) {
            var1.deallocate(this.bucketItems, this.size);

            for (int var2 = 0; var2 < this.size; var2++) {
               this.bucketItems[var2] = null;
            }

            this.size = 0;
            this.isUnsorted = false;
            this.isEmpty = true;
         }
      }

      class="kw">public void add(@Nonnull BucketItem<E> var1) {
         this.isEmpty = false;
         if (this.size == this.bucketItems.length) {
            this.bucketItems = (BucketItem<E>[])ObjectArrays.grow(this.bucketItems, this.size + 1);
         }

         this.bucketItems[this.size++] = var1;
         this.isUnsorted = true;
      }

      class="kw">public void sort(@Nonnull BucketList.SortBufferProvider var1) {
         this.isUnsorted = false;
         if (this.size > 1) {
            BucketItem[] var2 = var1.apply(this.size);
            System.arraycopy(this.bucketItems, 0, var2, 0, this.size);
            ObjectArrays.mergeSort(this.bucketItems, 0, this.size, BucketList.CLOSER_TO_SELF, var2);
         }
      }
   }

   class="kw">public class="kw">static class SortBufferProvider class="kw">implements IntFunction<BucketItem[]> {
      class="kw">protected BucketItem[] buffer = new BucketItem[4];

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

      class="kw">public BucketItem[] apply(int var1) {
         if (var1 <= this.buffer.length) {
            class="kw">return this.buffer;
         }

         this.buffer = (BucketItem[])ObjectArrays.grow(this.buffer, var1);
         class="kw">return this.buffer;
      }
   }
}