class="kw">package com.hypixel.hytale.server.spawning.util;

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.server.core.modules.time.WorldTimeResource;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.BlockSection;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.section.ChunkLightData;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.spawning.assets.spawns.LightType;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class LightRangePredicate {
   class="kw">private byte lightValueMin;
   class="kw">private byte lightValueMax;
   class="kw">private byte skyLightValueMin;
   class="kw">private byte skyLightValueMax;
   class="kw">private byte sunlightValueMin;
   class="kw">private byte sunlightValueMax;
   class="kw">private byte redLightValueMin;
   class="kw">private byte redLightValueMax;
   class="kw">private byte greenLightValueMin;
   class="kw">private byte greenLightValueMax;
   class="kw">private byte blueLightValueMin;
   class="kw">private byte blueLightValueMax;
   class="kw">private boolean testLightValue;
   class="kw">private boolean testSkyLightValue;
   class="kw">private boolean testSunlightValue;
   class="kw">private boolean testRedLightValue;
   class="kw">private boolean testGreenLightValue;
   class="kw">private boolean testBlueLightValue;

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

   class="kw">public class="kw">static int lightToPrecentage(byte var0) {
      class="kw">return MathUtil.fastRound(var0 * 100.0F / 15.0F);
   }

   class="kw">public void setLightRange(@Nonnull LightType var1, double[] var2) {
      class="kw">switch (var1) {
         case Light:
            this.setLightRange(var2);
            break;
         case SkyLight:
            this.setSkyLightRange(var2);
            break;
         case Sunlight:
            this.setSunlightRange(var2);
            break;
         case RedLight:
            this.setRedLightRange(var2);
            break;
         case GreenLight:
            this.setGreenLightRange(var2);
            break;
         case BlueLight:
            this.setBlueLightRange(var2);
      }
   }

   class="kw">public void setLightRange(@Nullable double[] var1) {
      this.testLightValue = var1 != null;
      if (this.testLightValue) {
         this.lightValueMin = this.lightPercentageToAbsolute(var1[0]);
         this.lightValueMax = this.lightPercentageToAbsolute(var1[1]);
         this.testLightValue = this.isPartialRange(this.lightValueMin, this.lightValueMax);
      }
   }

   class="kw">public void setSkyLightRange(@Nullable double[] var1) {
      this.testSkyLightValue = var1 != null;
      if (this.testSkyLightValue) {
         this.skyLightValueMin = this.lightPercentageToAbsolute(var1[0]);
         this.skyLightValueMax = this.lightPercentageToAbsolute(var1[1]);
         this.testSkyLightValue = this.isPartialRange(this.skyLightValueMin, this.skyLightValueMax);
      }
   }

   class="kw">public void setSunlightRange(@Nullable double[] var1) {
      this.testSunlightValue = var1 != null;
      if (this.testSunlightValue) {
         this.sunlightValueMin = this.lightPercentageToAbsolute(var1[0]);
         this.sunlightValueMax = this.lightPercentageToAbsolute(var1[1]);
         this.testSunlightValue = this.isPartialRange(this.sunlightValueMin, this.sunlightValueMax);
      }
   }

   class="kw">public void setRedLightRange(@Nullable double[] var1) {
      this.testRedLightValue = var1 != null;
      if (this.testRedLightValue) {
         this.redLightValueMin = this.lightPercentageToAbsolute(var1[0]);
         this.redLightValueMax = this.lightPercentageToAbsolute(var1[1]);
         this.testRedLightValue = this.isPartialRange(this.redLightValueMin, this.redLightValueMax);
      }
   }

   class="kw">public void setGreenLightRange(@Nullable double[] var1) {
      this.testGreenLightValue = var1 != null;
      if (this.testGreenLightValue) {
         this.greenLightValueMin = this.lightPercentageToAbsolute(var1[0]);
         this.greenLightValueMax = this.lightPercentageToAbsolute(var1[1]);
         this.testGreenLightValue = this.isPartialRange(this.greenLightValueMin, this.greenLightValueMax);
      }
   }

   class="kw">public void setBlueLightRange(@Nullable double[] var1) {
      this.testBlueLightValue = var1 != null;
      if (this.testBlueLightValue) {
         this.blueLightValueMin = this.lightPercentageToAbsolute(var1[0]);
         this.blueLightValueMax = this.lightPercentageToAbsolute(var1[1]);
         this.testBlueLightValue = this.isPartialRange(this.blueLightValueMin, this.blueLightValueMax);
      }
   }

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

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

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

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

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

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

   class="kw">public boolean test(@Nonnull World var1, @Nonnull Vector3d var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      int var4 = MathUtil.floor(var2.x());
      int var5 = MathUtil.floor(var2.y());
      int var6 = MathUtil.floor(var2.z());
      WorldTimeResource var7 = var3.getResource(WorldTimeResource.getResourceType());
      ChunkStore var8 = var1.getChunkStore();
      Ref var9 = var8.getChunkSectionReferenceAtBlock(var4, var5, var6);
      class="kw">return var9 != null && var9.isValid() && this.test(var8.getStore(), var9, var4, var5, var6, var7.getSunlightFactor());
   }

   class="kw">public boolean test(ComponentAccessor<ChunkStore> var1, @Nonnull Ref<ChunkStore> var2, int var3, int var4, int var5, double var6) {
      BlockSection var8 = var1.getComponent(var2, BlockSection.getComponentType());
      if (var8 == null) {
         class="kw">return false;
      }

      ChunkLightData var9 = var8.getGlobalLight();
      if (this.testLightValue) {
         byte var10 = calculateLightValue(var8, var3, var4, var5, var6);
         if (!this.testLight(var10)) {
            class="kw">return false;
         }
      }

      if (this.testSkyLightValue) {
         byte var11 = var9.getSkyLight(var3, var4, var5);
         if (!this.testSkyLight(var11)) {
            class="kw">return false;
         }
      }

      if (this.testSunlightValue) {
         byte var12 = (byte)(var9.getSkyLight(var3, var4, var5) * var6);
         if (!this.testSunlight(var12)) {
            class="kw">return false;
         }
      }

      if (this.testRedLightValue) {
         byte var13 = var9.getRedBlockLight(var3, var4, var5);
         if (!this.testRedLight(var13)) {
            class="kw">return false;
         }
      }

      if (this.testGreenLightValue) {
         byte var14 = var9.getGreenBlockLight(var3, var4, var5);
         if (!this.testGreenLight(var14)) {
            class="kw">return false;
         }
      }

      if (this.testBlueLightValue) {
         byte var15 = var9.getBlueBlockLight(var3, var4, var5);
         if (!this.testBlueLight(var15)) {
            class="kw">return false;
         }
      }

      class="kw">return true;
   }

   class="kw">public boolean testLight(byte var1) {
      class="kw">return this.test(var1, this.lightValueMin, this.lightValueMax);
   }

   class="kw">public boolean testSkyLight(byte var1) {
      class="kw">return this.test(var1, this.skyLightValueMin, this.skyLightValueMax);
   }

   class="kw">public boolean testSunlight(byte var1) {
      class="kw">return this.test(var1, this.sunlightValueMin, this.sunlightValueMax);
   }

   class="kw">public boolean testRedLight(byte var1) {
      class="kw">return this.test(var1, this.redLightValueMin, this.redLightValueMax);
   }

   class="kw">public boolean testGreenLight(byte var1) {
      class="kw">return this.test(var1, this.greenLightValueMin, this.greenLightValueMax);
   }

   class="kw">public boolean testBlueLight(byte var1) {
      class="kw">return this.test(var1, this.blueLightValueMin, this.blueLightValueMax);
   }

   class="kw">public class="kw">static byte calculateLightValue(@Nonnull BlockSection var0, int var1, int var2, int var3, double var4) {
      ChunkLightData var6 = var0.getGlobalLight();
      int var7 = var6.getBlockLightIntensity(var1, var2, var3);
      byte var8 = (byte)(var6.getSkyLight(var1, var2, var3) * var4);
      class="kw">return (byte)Math.max(var8, var7);
   }

   class="kw">private boolean test(byte var1, byte var2, byte var3) {
      class="kw">return var1 >= var2 && var1 <= var3;
   }

   class="kw">private byte lightPercentageToAbsolute(double var1) {
      class="kw">return (byte)MathUtil.fastRound(var1 * 0.15);
   }

   class="kw">private boolean isPartialRange(byte var1, byte var2) {
      class="kw">return var1 > 0 || var2 < 15;
   }
}