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

class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Resource;
class="kw">import com.hypixel.hytale.component.ResourceType;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.util.MathUtil;
class="kw">import com.hypixel.hytale.math.util.TrigMathUtil;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.protocol.InstantData;
class="kw">import com.hypixel.hytale.protocol.packets.world.UpdateTime;
class="kw">import com.hypixel.hytale.protocol.packets.world.UpdateTimeSettings;
class="kw">import com.hypixel.hytale.server.core.asset.type.gameplay.WorldConfig;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.PlayerUtil;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.events.ecs.MoonPhaseChangeEvent;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import java.time.Instant;
class="kw">import java.time.LocalDateTime;
class="kw">import java.time.ZoneOffset;
class="kw">import java.time.temporal.ChronoField;
class="kw">import java.time.temporal.ChronoUnit;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3d;

class="kw">public class WorldTimeResource class="kw">implements Resource<EntityStore> {
   class="kw">public class="kw">static class="kw">final long NANOS_PER_DAY = ChronoUnit.DAYS.getDuration().toNanos();
   class="kw">public class="kw">static class="kw">final int SECONDS_PER_DAY = (int)ChronoUnit.DAYS.getDuration().toSeconds();
   class="kw">public class="kw">static class="kw">final int HOURS_PER_DAY = (int)ChronoUnit.DAYS.getDuration().toHours();
   class="kw">public class="kw">static class="kw">final int DAYS_PER_YEAR = (int)ChronoUnit.YEARS.getDuration().toDays();
   class="kw">public class="kw">static class="kw">final Instant ZERO_YEAR = Instant.parse("0001-01-01T00:00:00.00Z");
   class="kw">public class="kw">static class="kw">final Instant MAX_TIME = Instant.ofEpochSecond(31553789759L, 99999999L);
   class="kw">public class="kw">static class="kw">final ZoneOffset ZONE_OFFSET = ZoneOffset.UTC;
   class="kw">public class="kw">static class="kw">final float SUN_HEIGHT = 2.0F;
   class="kw">public class="kw">static class="kw">final boolean USE_SHADOW_MAPPING_SAFE_ANGLE = true;
   class="kw">public class="kw">static class="kw">final float DAYTIME_PORTION_PERCENTAGE = 0.6F;
   class="kw">public class="kw">static class="kw">final int DAYTIME_SECONDS = (int)(SECONDS_PER_DAY * 0.6F);
   class="kw">public class="kw">static class="kw">final int NIGHTTIME_SECONDS = (int)(SECONDS_PER_DAY * 0.39999998F);
   class="kw">public class="kw">static class="kw">final int SUNRISE_SECONDS = NIGHTTIME_SECONDS / 2;
   class="kw">public class="kw">static class="kw">final float SHADOW_MAPPING_SAFE_ANGLE_LERP = 0.35F;
   @Nonnull
   class="kw">private class="kw">final UpdateTime currentTimePacket = new UpdateTime();
   class="kw">private Instant gameTime;
   class="kw">private LocalDateTime _gameTimeLocalDateTime;
   class="kw">private int currentHour;
   class="kw">private double sunlightFactor;
   class="kw">private double scaledTime;
   class="kw">private int moonPhase;
   class="kw">private boolean interpolating = false;
   class="kw">private double interpRemainingSeconds = 0.0;
   class="kw">private Instant interpTargetTime;
   class="kw">private boolean interpPauseOnComplete = false;
   @Nonnull
   class="kw">private class="kw">final UpdateTimeSettings currentSettings = new UpdateTimeSettings();
   @Nonnull
   class="kw">private class="kw">final UpdateTimeSettings tempSettings = new UpdateTimeSettings();

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

   @Nonnull
   class="kw">public class="kw">static ResourceType<EntityStore, WorldTimeResource> getResourceType() {
      class="kw">return TimeModule.get().getWorldTimeResourceType();
   }

   class="kw">public class="kw">static double getSecondsPerTick(World var0) {
      int var1 = var0.getDaytimeDurationSeconds();
      int var2 = var0.getNighttimeDurationSeconds();
      int var3 = var1 + var2;
      class="kw">return (double)SECONDS_PER_DAY / var3;
   }

   class="kw">public void tick(float var1, @Nonnull Store<EntityStore> var2) {
      World var3 = var2.getExternalData().getWorld();
      if (!updateTimeSettingsPacket(this.tempSettings, var3).equals(this.currentSettings)) {
         boolean var4 = this.currentSettings.timePaused != this.tempSettings.timePaused;
         updateTimeSettingsPacket(this.currentSettings, var3);
         PlayerUtil.broadcastPacketToPlayers(var2, this.currentSettings);
         if (var4) {
            this.broadcastTimePacket(var2);
         }
      }

      if (this.interpolating) {
         long var30 = ChronoUnit.NANOS.between(this.gameTime, this.interpTargetTime);
         if (!(var1 >= this.interpRemainingSeconds) && !(this.interpRemainingSeconds <= 0.0) && var30 != 0L) {
            long var31 = (long)(var30 * (var1 / this.interpRemainingSeconds));
            this.setGameTime(this.gameTime.plusNanos(var31), var3, var2);
            this.interpRemainingSeconds -= var1;
         } else {
            this.setGameTime(this.interpTargetTime, var3, var2);
            this.interpolating = false;
            if (this.interpPauseOnComplete) {
               setTimePaused(var3, true);
            }
         }
      } else if (!var3.getWorldConfig().isGameTimePaused()) {
         int var29 = this._gameTimeLocalDateTime.get(ChronoField.SECOND_OF_DAY);
         int var5 = var3.getDaytimeDurationSeconds();
         int var6 = var3.getNighttimeDurationSeconds();
         int var7 = var5 + var6;
         double var8 = (double)DAYTIME_SECONDS / var5;
         double var10 = (double)NIGHTTIME_SECONDS / var6;
         double var12;
         if (var29 >= SUNRISE_SECONDS && var29 < SUNRISE_SECONDS + DAYTIME_SECONDS) {
            var12 = (var29 - SUNRISE_SECONDS) / var8;
         } else {
            var12 = var5 + MathUtil.floorMod(var29 - SUNRISE_SECONDS - DAYTIME_SECONDS, SECONDS_PER_DAY) / var10;
         }

         double var14 = var12 + var1;
         long var16 = (long)Math.floor(var14 / var7) - (long)Math.floor(var12 / var7);
         double var18 = MathUtil.floorMod(var12, var7);
         double var20 = MathUtil.floorMod(var14, var7);
         double var22 = var18 <= var5 ? var8 * var18 : DAYTIME_SECONDS + var10 * (var18 - var5);
         double var24 = var20 <= var5 ? var8 * var20 : DAYTIME_SECONDS + var10 * (var20 - var5);
         double var26 = var16 * SECONDS_PER_DAY + (var24 - var22);
         Instant var28 = this.gameTime.plusNanos((long)(var26 * 1.0E9));
         if (var28.isBefore(ZERO_YEAR)) {
            var28 = MAX_TIME.minusSeconds(ZERO_YEAR.getEpochSecond() - this.gameTime.getEpochSecond())
               .minusNanos(ZERO_YEAR.getNano() - this.gameTime.getNano());
         }

         if (var28.isAfter(MAX_TIME)) {
            var28 = ZERO_YEAR.plusSeconds(MAX_TIME.getEpochSecond() - this.gameTime.getEpochSecond()).plusNanos(MAX_TIME.getNano() - this.gameTime.getNano());
         }

         this.setGameTime0(var28);
         this.updateMoonPhase(var3, var2);
      }
   }

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

   class="kw">public void setMoonPhase(int var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      if (var1 != this.moonPhase) {
         MoonPhaseChangeEvent var3 = new MoonPhaseChangeEvent(var1);
         var2.invoke(var3);
      }

      this.moonPhase = var1;
   }

   class="kw">public void updateMoonPhase(@Nonnull World var1, @Nonnull ComponentAccessor<EntityStore> var2) {
      WorldConfig var3 = var1.getGameplayConfig().getWorldConfig();
      int var4 = var3.getTotalMoonPhases();
      double var5 = (double)this.currentHour / HOURS_PER_DAY;
      int var7 = this._gameTimeLocalDateTime.getDayOfYear();
      int var8 = (var7 - 1) % var4;
      if (var5 < 0.5) {
         if (var8 == 0) {
            this.setMoonPhase(var4 - 1, var2);
         } else {
            this.setMoonPhase(var8 - 1, var2);
         }
      } else {
         this.setMoonPhase(var8, var2);
      }
   }

   class="kw">public boolean isMoonPhaseWithinRange(@Nonnull World var1, int var2, int var3) {
      WorldConfig var4 = var1.getGameplayConfig().getWorldConfig();
      int var5 = var4.getTotalMoonPhases();
      class="kw">return var2 <= var3
         ? MathUtil.within(this.moonPhase, var2, var3)
         : MathUtil.within(this.moonPhase, var2, var5) || MathUtil.within(this.moonPhase, 0.0, var3);
   }

   class="kw">public void setGameTime0(@Nonnull Instant var1) {
      this.gameTime = var1;
      this._gameTimeLocalDateTime = LocalDateTime.ofInstant(var1, ZONE_OFFSET);
      this.updateTimePacket(this.currentTimePacket);
      this.currentHour = this._gameTimeLocalDateTime.getHour();
      int var2 = this._gameTimeLocalDateTime.get(ChronoField.SECOND_OF_DAY);
      float var3 = 0.6F * SECONDS_PER_DAY;
      float var4 = SECONDS_PER_DAY - var3;
      float var5 = var4 * 0.5F;
      this.updateSunlightFactor(var2, var5);
      this.updateScaledTime(var2, var3, var5);
   }

   class="kw">private void updateSunlightFactor(int var1, float var2) {
      float var3 = (var1 - var2) / SECONDS_PER_DAY;
      this.sunlightFactor = MathUtil.clamp(TrigMathUtil.sin((float) (Math.PI * 2) * var3) + 0.2, 0.0, 1.0);
   }

   class="kw">private void updateScaledTime(float var1, float var2, float var3) {
      if (var1 <= var3) {
         this.scaledTime = MathUtil.lerp(0.0F, 0.25F, var1 / var3);
      } else {
         var1 -= var3;
         if (var1 <= var2) {
            this.scaledTime = MathUtil.lerp(0.25F, 0.75F, var1 / var2);
         } else {
            var1 -= var2;
            this.scaledTime = MathUtil.lerp(0.75F, 1.0F, var1 / var3);
         }
      }
   }

   class="kw">public Instant getGameTime() {
      class="kw">return this.gameTime;
   }

   class="kw">public LocalDateTime getGameDateTime() {
      class="kw">return this._gameTimeLocalDateTime;
   }

   class="kw">public double getSunlightFactor() {
      class="kw">return this.sunlightFactor;
   }

   class="kw">public void setGameTime(@Nonnull Instant var1, @Nonnull World var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      this.setGameTime0(var1);
      this.updateMoonPhase(var2, var3);
      this.broadcastTimePacket(var3);
   }

   class="kw">public void setDayTime(double var1, @Nonnull World var3, @Nonnull ComponentAccessor<EntityStore> var4) {
      if (!(var1 < 0.0) && !(var1 > 1.0)) {
         Instant var5 = this.gameTime;
         Instant var6 = var5.truncatedTo(ChronoUnit.DAYS);
         Instant var7 = var6.plusNanos((long)(var1 * NANOS_PER_DAY));
         if (var7.isBefore(var5)) {
            this.setGameTime(var7.plus(1L, ChronoUnit.DAYS), var3, var4);
         } else {
            this.setGameTime(var7, var3, var4);
         }
      } else {
         throw new IllegalArgumentException("Day time must be between 0 and 1");
      }
   }

   class="kw">public void startDayTimeInterpolation(
      double var1, double var3, boolean var5, boolean var6, @Nonnull World var7, @Nonnull ComponentAccessor<EntityStore> var8
   ) {
      if (!(var1 < 0.0) && !(var1 > 1.0)) {
         Instant var9 = this.gameTime.truncatedTo(ChronoUnit.DAYS);
         Instant var10 = var9.plusNanos((long)(var1 * NANOS_PER_DAY));
         if (var5) {
            if (var10.isBefore(this.gameTime)) {
               var10 = var10.plus(1L, ChronoUnit.DAYS);
            }
         } else if (var10.isAfter(this.gameTime)) {
            var10 = var10.minus(1L, ChronoUnit.DAYS);
         }

         if (var3 <= 0.0) {
            this.interpolating = false;
            this.setGameTime(var10, var7, var8);
            if (var6) {
               setTimePaused(var7, true);
            }
         } else {
            this.interpTargetTime = var10;
            this.interpRemainingSeconds = var3;
            this.interpPauseOnComplete = var6;
            this.interpolating = true;
         }
      } else {
         throw new IllegalArgumentException("Day time must be between 0 and 1");
      }
   }

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

   class="kw">public void cancelInterpolation() {
      this.interpolating = false;
   }

   class="kw">private class="kw">static void setTimePaused(@Nonnull World var0, boolean var1) {
      if (var0.getWorldConfig().isGameTimePaused() != var1) {
         var0.getWorldConfig().setGameTimePaused(var1);
         var0.getWorldConfig().markChanged();
      }
   }

   class="kw">public void broadcastTimePacket(@Nonnull ComponentAccessor<EntityStore> var1) {
      PlayerUtil.broadcastPacketToPlayers(var1, this.currentTimePacket);
   }

   class="kw">public void sendTimePackets(@Nonnull PlayerRef var1) {
      var1.getPacketHandler().write(this.currentSettings);
      var1.getPacketHandler().write(this.currentTimePacket);
   }

   class="kw">public boolean isDayTimeWithinRange(double var1, double var3) {
      double var5 = this.getDayProgress();
      class="kw">return !(var1 > var3) ? MathUtil.within(var5, var1, var3) : MathUtil.within(var5, var1, 1.0) || MathUtil.within(var5, 0.0, var3);
   }

   class="kw">public void updateTimePacket(@Nonnull UpdateTime var1) {
      if (var1.gameTime == null) {
         var1.gameTime = new InstantData();
      }

      var1.gameTime.seconds = this.gameTime.getEpochSecond();
      var1.gameTime.nanos = this.gameTime.getNano();
   }

   @Nonnull
   class="kw">public class="kw">static UpdateTimeSettings updateTimeSettingsPacket(@Nonnull UpdateTimeSettings var0, @Nonnull World var1) {
      WorldConfig var2 = var1.getGameplayConfig().getWorldConfig();
      var0.daytimeDurationSeconds = var1.getDaytimeDurationSeconds();
      var0.nighttimeDurationSeconds = var1.getNighttimeDurationSeconds();
      var0.totalMoonPhases = (byte)var2.getTotalMoonPhases();
      var0.timePaused = var1.getWorldConfig().isGameTimePaused();
      class="kw">return var0;
   }

   class="kw">public boolean isScaledDayTimeWithinRange(double var1, double var3) {
      class="kw">return !(var1 > var3)
         ? MathUtil.within(this.scaledTime, var1, var3)
         : MathUtil.within(this.scaledTime, var1, 1.0) || MathUtil.within(this.scaledTime, 0.0, var3);
   }

   class="kw">public boolean isYearWithinRange(double var1, double var3) {
      class="kw">return false;
   }

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

   class="kw">public float getDayProgress() {
      class="kw">return (float)this._gameTimeLocalDateTime.get(ChronoField.SECOND_OF_DAY) / SECONDS_PER_DAY;
   }

   @Nonnull
   class="kw">public Instant dayProgressToInstant(double var1) {
      class="kw">return this.gameTime.truncatedTo(ChronoUnit.DAYS).plusNanos((long)(var1 * NANOS_PER_DAY));
   }

   @Nonnull
   class="kw">public Vector3d getSunDirection() {
      float var1 = this.getDayProgress() * HOURS_PER_DAY;
      float var2 = 0.6F * HOURS_PER_DAY;
      float var3 = HOURS_PER_DAY - var2;
      float var4 = var3 * 0.5F;
      float var5;
      if (var1 < var4) {
         float var6 = 1.0F / (var3 * 2.0F);
         var5 = MathUtil.wrapAngle((var1 * var6 - var4 * var6) * (float) (Math.PI * 2));
      } else if (var1 > HOURS_PER_DAY - var4) {
         float var9 = 1.0F / (var3 * 2.0F);
         var5 = MathUtil.wrapAngle((var1 * var9 - (HOURS_PER_DAY + var4) * var9) * (float) (Math.PI * 2));
      } else {
         float var10 = var2 * 0.5F;
         float var7 = 1.0F / (var2 * 2.0F);
         var5 = MathUtil.wrapAngle((var1 * var7 - (HOURS_PER_DAY * 0.5F - var10) * var7) * (float) (Math.PI * 2));
      }

      Vector3d var11 = new Vector3d(TrigMathUtil.cos(var5), TrigMathUtil.sin(var5) * 2.0F, TrigMathUtil.sin(var5));
      var11.normalize();
      double var12 = var11.y + 0.2F;
      if (var12 > 0.0) {
         var11.negate();
      }

      var11.x = MathUtil.lerp(var11.x, Vector3dUtil.DOWN.x(), 0.35F);
      var11.y = MathUtil.lerp(var11.y, Vector3dUtil.DOWN.y(), 0.35F);
      var11.z = MathUtil.lerp(var11.z, Vector3dUtil.DOWN.z(), 0.35F);
      class="kw">return var11;
   }

   @Nonnull
   class="kw">public class="kw">static InstantData instantToInstantData(@Nonnull Instant var0) {
      class="kw">return new InstantData(var0.getEpochSecond(), var0.getNano());
   }

   @Nonnull
   class="kw">public class="kw">static Instant instantDataToInstant(@Nonnull InstantData var0) {
      class="kw">return Instant.ofEpochSecond(var0.seconds, var0.nanos);
   }

   @Nonnull
   @Override
   class="kw">public Resource<EntityStore> clone() {
      WorldTimeResource var1 = new WorldTimeResource();
      var1.gameTime = this.gameTime;
      var1._gameTimeLocalDateTime = this._gameTimeLocalDateTime;
      var1.currentHour = this.currentHour;
      var1.sunlightFactor = this.sunlightFactor;
      var1.scaledTime = this.scaledTime;
      var1.moonPhase = this.moonPhase;
      var1.interpolating = this.interpolating;
      var1.interpRemainingSeconds = this.interpRemainingSeconds;
      var1.interpTargetTime = this.interpTargetTime;
      var1.interpPauseOnComplete = this.interpPauseOnComplete;
      class="kw">return var1;
   }

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