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

class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import com.hypixel.hytale.function.function.BiDoubleToDoubleFunction;
class="kw">import com.hypixel.hytale.function.function.BiIntToDoubleFunction;
class="kw">import com.hypixel.hytale.function.function.BiLongToDoubleFunction;
class="kw">import java.util.Arrays;
class="kw">import java.util.Collections;
class="kw">import java.util.HashSet;
class="kw">import java.util.Random;
class="kw">import java.util.Set;
class="kw">import java.util.function.Consumer;
class="kw">import java.util.function.DoubleSupplier;
class="kw">import java.util.function.Function;
class="kw">import java.util.function.IntFunction;
class="kw">import java.util.function.ObjDoubleConsumer;
class="kw">import java.util.function.ToDoubleFunction;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class WeightedMap<T> class="kw">implements IWeightedMap<T> {
   class="kw">public class="kw">static class="kw">final double EPSILON = 0.99999;
   class="kw">public class="kw">static class="kw">final double ONE_MINUS_EPSILON = 9.99999999995449E-6;
   @Nonnull
   class="kw">private class="kw">final Set<T> keySet = new HashSet<>();
   @Nonnull
   class="kw">private class="kw">final T[] keys;
   class="kw">private class="kw">final double[] values;
   class="kw">private class="kw">final double sum;

   @Nonnull
   class="kw">public class="kw">static <T> WeightedMap.Builder<T> builder(T[] var0) {
      class="kw">return new WeightedMap.Builder<>(var0);
   }

   class="kw">private WeightedMap(@Nonnull T[] var1, double[] var2, double var3) {
      Collections.addAll(this.keySet, var1);
      this.keys = var1;
      this.values = var2;
      this.sum = var3;
   }

   @Nullable
   @Override
   class="kw">public T get(double var1) {
      double var3 = Math.min(var1, 0.99999) * this.sum;

      for (int var5 = 0; var5 < this.keys.length; var5++) {
         if ((var3 -= this.values[var5]) <= 9.99999999995449E-6) {
            class="kw">return this.keys[var5];
         }
      }

      class="kw">return null;
   }

   @Nullable
   @Override
   class="kw">public T get(@Nonnull DoubleSupplier var1) {
      class="kw">return this.get(var1.getAsDouble());
   }

   @Nullable
   @Override
   class="kw">public T get(@Nonnull Random var1) {
      class="kw">return this.get(var1.nextDouble());
   }

   @Nullable
   @Override
   class="kw">public T get(int var1, int var2, @Nonnull BiIntToDoubleFunction var3) {
      class="kw">return this.get(var3.apply(var1, var2));
   }

   @Nullable
   @Override
   class="kw">public T get(long var1, long var3, @Nonnull BiLongToDoubleFunction var5) {
      class="kw">return this.get(var5.apply(var1, var3));
   }

   @Nullable
   @Override
   class="kw">public T get(double var1, double var3, @Nonnull BiDoubleToDoubleFunction var5) {
      class="kw">return this.get(var5.apply(var1, var3));
   }

   @Nullable
   @Override
   class="kw">public <K> T get(int var1, int var2, int var3, @Nonnull IWeightedMap.SeedCoordinateFunction<K> var4, K var5) {
      class="kw">return this.get(var4.apply(var1, var2, var3, var5));
   }

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

   @Override
   class="kw">public boolean contains(T var1) {
      class="kw">return this.keySet.contains(var1);
   }

   @Override
   class="kw">public void forEach(@Nonnull Consumer<T> var1) {
      for (Object var5 : this.keys) {
         var1.accept(var5);
      }
   }

   @Override
   class="kw">public void forEachEntry(@Nonnull ObjDoubleConsumer<T> var1) {
      for (int var2 = 0; var2 < this.keys.length; var2++) {
         var1.accept(this.keys[var2], this.values[var2]);
      }
   }

   @Nonnull
   @Override
   class="kw">public T[] internalKeys() {
      class="kw">return this.keys;
   }

   @Nonnull
   @Override
   class="kw">public T[] toArray() {
      class="kw">return (T[])Arrays.copyOf(this.keys, this.keys.length);
   }

   @Nonnull
   @Override
   class="kw">public <K> IWeightedMap<K> resolveKeys(@Nonnull Function<T, K> var1, @Nonnull IntFunction<K[]> var2) {
      Object[] var3 = (K[])var2.apply(this.keys.length);

      for (int var4 = 0; var4 < this.keys.length; var4++) {
         var3[var4] = var1.apply(this.keys[var4]);
      }

      class="kw">return new WeightedMap<>(var3, this.values, this.sum);
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "WeightedMap{keySet="
         + this.keySet
         + ", sum="
         + this.sum
         + ", keys="
         + Arrays.toString(this.keys)
         + ", values="
         + Arrays.toString(this.values)
         + "}";
   }

   class="kw">public class="kw">static class Builder<T> {
      class="kw">private class="kw">final T[] emptyKeys;
      class="kw">private T[] keys;
      class="kw">private double[] values;
      class="kw">private int size;

      class="kw">private Builder(T[] var1) {
         this.emptyKeys = var1;
         this.keys = var1;
         this.values = ArrayUtil.EMPTY_DOUBLE_ARRAY;
      }

      @Nonnull
      class="kw">public WeightedMap.Builder<T> putAll(@Nullable IWeightedMap<T> var1) {
         if (var1 != null) {
            this.ensureCapacity(var1.size());
            var1.forEachEntry(this::insert);
         }

         class="kw">return this;
      }

      @Nonnull
      class="kw">public WeightedMap.Builder<T> putAll(@Nullable T[] var1, @Nonnull ToDoubleFunction<T> var2) {
         if (var1 != null && var1.length != 0) {
            this.ensureCapacity(var1.length);

            for (Object var6 : var1) {
               this.insert(var6, var2.applyAsDouble(var6));
            }

            class="kw">return this;
         } else {
            class="kw">return this;
         }
      }

      @Nonnull
      class="kw">public WeightedMap.Builder<T> put(T var1, double var2) {
         this.ensureCapacity(1);
         this.insert(var1, var2);
         class="kw">return this;
      }

      class="kw">public void ensureCapacity(int var1) {
         int var2 = this.size + var1;
         int var3 = this.allocated();
         if (var2 > var3) {
            int var4 = Math.max(var3 + (var3 >> 1), var2);
            this.resize(var4);
         }
      }

      class="kw">private void resize(int var1) {
         this.keys = (T[])Arrays.copyOf(this.keys, var1);
         this.values = Arrays.copyOf(this.values, var1);
      }

      class="kw">private void insert(T var1, double var2) {
         this.keys[this.size] = var1;
         this.values[this.size] = var2;
         this.size++;
      }

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

      class="kw">private int allocated() {
         class="kw">return this.keys.length;
      }

      class="kw">public void clear() {
         this.keys = this.emptyKeys;
         this.values = ArrayUtil.EMPTY_DOUBLE_ARRAY;
         this.size = 0;
      }

      @Nonnull
      class="kw">public IWeightedMap<T> build() {
         if (this.size < this.allocated()) {
            this.resize(this.size);
         }

         if (this.keys.length != 0 && this.keys.length != 1) {
            double var1 = 0.0;

            for (double var6 : this.values) {
               var1 += var6;
            }

            class="kw">return new WeightedMap<>(this.keys, this.values, var1);
         } else {
            class="kw">return new WeightedMap.SingletonWeightedMap<>(this.keys);
         }
      }
   }

   class="kw">private class="kw">static class SingletonWeightedMap<T> class="kw">implements IWeightedMap<T> {
      @Nonnull
      class="kw">protected class="kw">final T[] keys;
      class="kw">protected class="kw">final T key;

      class="kw">private SingletonWeightedMap(@Nonnull T[] var1) {
         this.keys = var1;
         this.key = var1.length > 0 ? var1[0] : null;
      }

      @Override
      class="kw">public T get(double var1) {
         class="kw">return this.key;
      }

      @Override
      class="kw">public T get(DoubleSupplier var1) {
         class="kw">return this.key;
      }

      @Override
      class="kw">public T get(Random var1) {
         class="kw">return this.key;
      }

      @Override
      class="kw">public T get(int var1, int var2, BiIntToDoubleFunction var3) {
         class="kw">return this.key;
      }

      @Override
      class="kw">public T get(long var1, long var3, BiLongToDoubleFunction var5) {
         class="kw">return this.key;
      }

      @Override
      class="kw">public T get(double var1, double var3, BiDoubleToDoubleFunction var5) {
         class="kw">return this.key;
      }

      @Override
      class="kw">public <K> T get(int var1, int var2, int var3, IWeightedMap.SeedCoordinateFunction<K> var4, K var5) {
         class="kw">return this.key;
      }

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

      @Override
      class="kw">public boolean contains(@Nullable T var1) {
         class="kw">return var1 != null && (var1 == this.key || var1.equals(this.key));
      }

      @Override
      class="kw">public void forEach(@Nonnull Consumer<T> var1) {
         if (this.key != null) {
            var1.accept(this.key);
         }
      }

      @Override
      class="kw">public void forEachEntry(@Nonnull ObjDoubleConsumer<T> var1) {
         if (this.key != null) {
            var1.accept(this.key, 1.0);
         }
      }

      @Nonnull
      @Override
      class="kw">public T[] internalKeys() {
         class="kw">return this.keys;
      }

      @Nonnull
      @Override
      class="kw">public T[] toArray() {
         class="kw">return (T[])Arrays.copyOf(this.keys, this.keys.length);
      }

      @Nonnull
      @Override
      class="kw">public <K> IWeightedMap<K> resolveKeys(@Nonnull Function<T, K> var1, @Nonnull IntFunction<K[]> var2) {
         Object[] var3 = (K[])var2.apply(1);
         var3[0] = var1.apply(this.key);
         class="kw">return new WeightedMap.SingletonWeightedMap<>(var3);
      }

      @Nonnull
      @Override
      class="kw">public String toString() {
         class="kw">return "SingletonWeightedMap{key=" + this.key + "}";
      }
   }
}