class="kw">package com.hypixel.hytale.server.core.prefab;

class="kw">import com.hypixel.hytale.codec.Codec;
class="kw">import com.hypixel.hytale.codec.KeyedCodec;
class="kw">import com.hypixel.hytale.codec.builder.BuilderCodec;
class="kw">import com.hypixel.hytale.codec.codecs.map.Object2DoubleMapCodec;
class="kw">import com.hypixel.hytale.codec.validation.LegacyValidator;
class="kw">import com.hypixel.hytale.codec.validation.ValidationResults;
class="kw">import com.hypixel.hytale.codec.validation.Validators;
class="kw">import com.hypixel.hytale.common.util.ArrayUtil;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleMap;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleMaps;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleOpenHashMap;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectIterator;
class="kw">import it.unimi.dsi.fastutil.objects.Object2DoubleMap.Entry;
class="kw">import java.util.Random;
class="kw">import java.util.Set;
class="kw">import java.util.function.Function;
class="kw">import java.util.function.Supplier;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;

class="kw">public class PrefabWeights {
   class="kw">public class="kw">static class="kw">final Supplier<Object2DoubleMap<String>> MAP_SUPPLIER = Object2DoubleOpenHashMap::new;
   class="kw">public class="kw">static class="kw">final Codec<Object2DoubleMap<String>> MAP_CODEC = new Object2DoubleMapCodec<>(Codec.STRING, MAP_SUPPLIER, false);
   class="kw">public class="kw">static class="kw">final Codec<PrefabWeights> CODEC = BuilderCodec.builder(PrefabWeights.class, PrefabWeights::new)
      .append(new KeyedCodec<>("Default", Codec.DOUBLE), (var0, var1) -> var0.defaultWeight = var1, var0 -> var0.defaultWeight)
      .documentation("The class="kw">default weight to use for entries that are not specifically mapped to a weight value.")
      .addValidator(Validators.greaterThanOrEqual(0.0))
      .add()
      .<Object2DoubleMap<String>>append(new KeyedCodec<>("Weights", MAP_CODEC), (var0, var1) -> var0.weightsLookup = var1, var0 -> var0.weightsLookup)
      .documentation("The mapping of prefab names to weight values.")
      .addValidator(new PrefabWeights.WeightMapValidator())
      .add()
      .build();
   class="kw">public class="kw">static class="kw">final PrefabWeights NONE = new PrefabWeights(Object2DoubleMaps.emptyMap()) {
      {
         this.sum = 0.0;
         this.weights = ArrayUtil.EMPTY_DOUBLE_ARRAY;
         this.initialized = true;
      }
   };
   class="kw">public class="kw">static class="kw">final double DEFAULT_WEIGHT = 1.0;
   class="kw">public class="kw">static class="kw">final char DELIMITER_CHAR = ',';
   class="kw">public class="kw">static class="kw">final char ASSIGNMENT_CHAR = '=';
   class="kw">private double defaultWeight;
   class="kw">private Object2DoubleMap<String> weightsLookup;
   class="kw">protected double sum;
   class="kw">protected double[] weights;
   class="kw">protected class="kw">volatile boolean initialized;

   class="kw">public PrefabWeights() {
      this(MAP_SUPPLIER.get());
   }

   class="kw">private PrefabWeights(Object2DoubleMap<String> var1) {
      this.weightsLookup = var1;
      this.defaultWeight = 1.0;
   }

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

   @Nullable
   class="kw">public <T> T get(@Nonnull T[] var1, @Nonnull Function<T, String> var2, @Nonnull Random var3) {
      class="kw">return this.get(var1, var2, var3.nextDouble());
   }

   @Nullable
   class="kw">public <T> T get(@Nonnull T[] var1, @Nonnull Function<T, String> var2, double var3) {
      if (var3 < 0.0) {
         class="kw">return null;
      }

      this.initialize(var1, var2);
      if (this.weights.length != var1.length) {
         class="kw">return null;
      }

      double var5 = Math.min(var3, 0.99999) * this.sum;

      for (int var7 = 0; var7 < this.weights.length; var7++) {
         if (var5 <= this.weights[var7]) {
            class="kw">return var1[var7];
         }
      }

      class="kw">return null;
   }

   class="kw">public double getWeight(String var1) {
      class="kw">return this.weightsLookup.getOrDefault(var1, this.defaultWeight);
   }

   class="kw">public void setWeight(String var1, double var2) {
      if (this != NONE) {
         checkWeight(var1, var2);
         this.weightsLookup.put(var1, var2);
      }
   }

   class="kw">public void removeWeight(String var1) {
      if (this != NONE) {
         this.weightsLookup.removeDouble(var1);
      }
   }

   class="kw">public double getDefaultWeight() {
      class="kw">return this.defaultWeight;
   }

   class="kw">public void setDefaultWeight(double var1) {
      if (this != NONE) {
         this.defaultWeight = Math.max(0.0, var1);
      }
   }

   @Nonnull
   class="kw">public String getMappingString() {
      if (this.weightsLookup.isEmpty()) {
         class="kw">return "";
      }

      StringBuilder var1 = new StringBuilder();
      ObjectIterator var2 = Object2DoubleMaps.fastIterable(this.weightsLookup).iterator();

      while (var2.hasNext()) {
         Entry var3 = (Entry<String>)var2.next();
         if (!var1.isEmpty()) {
            var1.append(',').append(' ');
         }

         var1.append((String)var3.getKey()).append('=').append(var3.getDoubleValue());
      }

      class="kw">return var1.toString();
   }

   @Nonnull
   @Override
   class="kw">public String toString() {
      class="kw">return "PrefabWeights{class="kw">default=" + this.defaultWeight + ", weights=" + this.getMappingString() + "}";
   }

   class="kw">private <T> void initialize(@Nonnull T[] var1, @Nonnull Function<T, String> var2) {
      if (!this.initialized) {
         class="kw">synchronized (this) {
            if (!this.initialized) {
               double var4 = 0.0;
               double[] var6 = new double[var1.length];

               for (int var7 = 0; var7 < var1.length; var7++) {
                  String var8 = var2.apply(var1[var7]);
                  var4 += this.getWeight(var8);
                  var6[var7] = var4;
               }

               this.sum = var4;
               this.weights = var6;
               this.initialized = true;
            }
         }
      }
   }

   @Nonnull
   class="kw">public class="kw">static PrefabWeights parse(@Nonnull String var0) {
      Object2DoubleMap var1 = null;

      for (int var9 = 0; var9 < var0.length(); var9++) {
         int var3 = var0.indexOf(44, var9);
         if (var3 == -1) {
            var3 = var0.length();
         }

         int var4 = var0.indexOf(61, var9);
         if (var4 <= var9) {
            break;
         }

         String var5 = var0.substring(var9, var4).trim();
         String var6 = var0.substring(var4 + 1, var3).trim();
         double var7 = Double.parseDouble(var6);
         if (var1 == null) {
            var1 = MAP_SUPPLIER.get();
         }

         var1.put(var5, var7);
         var9 = var3;
      }

      class="kw">return var1 == null ? NONE : new PrefabWeights(var1);
   }

   class="kw">public Set<Entry<String>> entrySet() {
      class="kw">return this.weightsLookup.object2DoubleEntrySet();
   }

   class="kw">private class="kw">static void checkWeight(String var0, double var1) {
      if (var1 < 0.0) {
         throw new IllegalArgumentException(String.format("Negative weight %.5f assigned to prefab %s", var1, var0));
      }
   }

   class="kw">private class="kw">static class WeightMapValidator class="kw">implements LegacyValidator<Object2DoubleMap<String>> {
      class="kw">private WeightMapValidator() {
      }

      class="kw">public void accept(@Nonnull Object2DoubleMap<String> var1, ValidationResults var2) {
         ObjectIterator var3 = Object2DoubleMaps.fastIterable(var1).iterator();

         while (var3.hasNext()) {
            Entry var4 = (Entry<String>)var3.next();
            PrefabWeights.checkWeight((String)var4.getKey(), var4.getDoubleValue());
         }
      }
   }
}