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

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.component.Component;
class="kw">import com.hypixel.hytale.protocol.BlockPosition;
class="kw">import com.hypixel.hytale.protocol.ToClientPacket;
class="kw">import com.hypixel.hytale.protocol.packets.world.UpdateBlockDamage;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.ChunkStore;
class="kw">import com.hypixel.hytale.server.core.util.io.MemorySegmentUtil;
class="kw">import it.unimi.dsi.fastutil.objects.Object2ObjectOpenHashMap;
class="kw">import java.lang.foreign.MemorySegment;
class="kw">import java.lang.foreign.ValueLayout;
class="kw">import java.time.Instant;
class="kw">import java.util.List;
class="kw">import java.util.Map;
class="kw">import java.util.Objects;
class="kw">import java.util.Map.Entry;
class="kw">import java.util.function.Predicate;
class="kw">import javax.annotation.Nonnull;
class="kw">import org.joml.Vector3i;

class="kw">public class BlockHealthChunk class="kw">implements Component<ChunkStore> {
   class="kw">private class="kw">static class="kw">final byte SERIALIZATION_VERSION = 2;
   class="kw">public class="kw">static class="kw">final BuilderCodec<BlockHealthChunk> CODEC = BuilderCodec.builder(BlockHealthChunk.class, BlockHealthChunk::new)
      .append(new KeyedCodec<>("Data", Codec.BYTE_ARRAY), BlockHealthChunk::deserialize, BlockHealthChunk::serialize)
      .documentation("Binary data representing the state of this BlockHealthChunk")
      .add()
      .<Instant>append(new KeyedCodec<>("LastRepairGameTime", Codec.INSTANT), (var0, var1) -> var0.lastRepairGameTime = var1, var0 -> var0.lastRepairGameTime)
      .documentation("The last tick of the world this BlockHealthChunk processed.")
      .add()
      .build();
   class="kw">private class="kw">final Map<Vector3i, BlockHealth> blockHealthMap = new Object2ObjectOpenHashMap(0);
   class="kw">private class="kw">final Map<Vector3i, FragileBlock> blockFragilityMap = new Object2ObjectOpenHashMap(0);
   class="kw">private Instant lastRepairGameTime;

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

   class="kw">public Instant getLastRepairGameTime() {
      class="kw">return this.lastRepairGameTime;
   }

   class="kw">public void setLastRepairGameTime(Instant var1) {
      this.lastRepairGameTime = var1;
   }

   @Nonnull
   class="kw">public Map<Vector3i, BlockHealth> getBlockHealthMap() {
      class="kw">return this.blockHealthMap;
   }

   @Nonnull
   class="kw">public Map<Vector3i, FragileBlock> getBlockFragilityMap() {
      class="kw">return this.blockFragilityMap;
   }

   @Nonnull
   class="kw">public BlockHealth damageBlock(Instant var1, @Nonnull World var2, @Nonnull Vector3i var3, float var4) {
      BlockHealth var5 = this.blockHealthMap.compute(var3, (var2x, var3x) -> {
         if (var3x == null) {
            var3x = new BlockHealth();
         }

         var3x.setHealth(var3x.getHealth() - var4);
         var3x.setLastDamageGameTime(var1);
         class="kw">return (BlockHealth)(var3x.getHealth() < 1.0 ? var3x : null);
      });
      if (var5 != null && !var5.isDestroyed()) {
         Predicate var6 = var0 -> true;
         var2.getNotificationHandler().updateBlockDamage(var3.x(), var3.y(), var3.z(), var5.getHealth(), -var4, var6);
      }

      class="kw">return Objects.requireNonNullElse(var5, BlockHealth.NO_DAMAGE_INSTANCE);
   }

   @Nonnull
   class="kw">public BlockHealth repairBlock(@Nonnull World var1, @Nonnull Vector3i var2, float var3) {
      BlockHealth var4 = Objects.requireNonNullElse(this.blockHealthMap.computeIfPresent(var2, (var1x, var2x) -> {
         var2x.setHealth(var2x.getHealth() + var3);
         class="kw">return (BlockHealth)(var2x.getHealth() > 1.0 ? var2x : null);
      }), BlockHealth.NO_DAMAGE_INSTANCE);
      var1.getNotificationHandler().updateBlockDamage(var2.x(), var2.y(), var2.z(), var4.getHealth(), var3);
      class="kw">return var4;
   }

   class="kw">public void removeBlock(@Nonnull World var1, @Nonnull Vector3i var2) {
      if (this.blockHealthMap.remove(var2) != null) {
         var1.getNotificationHandler().updateBlockDamage(var2.x(), var2.y(), var2.z(), BlockHealth.NO_DAMAGE_INSTANCE.getHealth(), 0.0F);
      }
   }

   class="kw">public void makeBlockFragile(Vector3i var1, float var2) {
      this.blockFragilityMap.compute(var1, (var1x, var2x) -> {
         if (var2x == null) {
            var2x = new FragileBlock(var2);
         }

         var2x.setDurationSeconds(var2);
         class="kw">return (FragileBlock)(var2x.getDurationSeconds() <= 0.0 ? null : var2x);
      });
   }

   class="kw">public boolean isBlockFragile(Vector3i var1) {
      class="kw">return this.blockFragilityMap.get(var1) != null;
   }

   class="kw">public float getBlockHealth(Vector3i var1) {
      class="kw">return this.blockHealthMap.getOrDefault(var1, BlockHealth.NO_DAMAGE_INSTANCE).getHealth();
   }

   class="kw">public void createBlockDamagePackets(@Nonnull List<ToClientPacket> var1) {
      for (Entry var3 : this.blockHealthMap.entrySet()) {
         Vector3i var4 = var3.getKey();
         BlockPosition var5 = new BlockPosition(var4.x(), var4.y(), var4.z());
         var1.add(new UpdateBlockDamage(var5, var3.getValue().getHealth(), 0.0F));
      }
   }

   @Nonnull
   class="kw">public BlockHealthChunk clone() {
      BlockHealthChunk var1 = new BlockHealthChunk();
      var1.lastRepairGameTime = this.lastRepairGameTime;

      for (Entry var3 : this.blockHealthMap.entrySet()) {
         var1.blockHealthMap.put(var3.getKey(), var3.getValue().clone());
      }

      for (Entry var5 : this.blockFragilityMap.entrySet()) {
         var1.blockFragilityMap.put(var5.getKey(), var5.getValue().clone());
      }

      class="kw">return var1;
   }

   class="kw">public void deserialize(@Nonnull byte[] var1) {
      this.blockHealthMap.clear();
      this.blockFragilityMap.clear();
      MemorySegment var2 = MemorySegment.ofArray(var1);
      byte var3 = var2.get(ValueLayout.JAVA_BYTE, 0L);
      int var4 = var2.get(MemorySegmentUtil.INT_BE, 1L);
      int var5 = 5;

      for (int var6 = 0; var6 < var4; var6++) {
         int var7 = var2.get(MemorySegmentUtil.INT_BE, var5);
         int var8 = var2.get(MemorySegmentUtil.INT_BE, var5 + 4);
         int var9 = var2.get(MemorySegmentUtil.INT_BE, var5 + 8);
         BlockHealth var10 = new BlockHealth();
         var10.deserialize(var2, var5 + 12, var3);
         this.blockHealthMap.put(new Vector3i(var7, var8, var9), var10);
         var5 += 24;
      }

      if (var3 > 1) {
         int var13 = var2.get(MemorySegmentUtil.INT_BE, var5);
         var5 += 4;

         for (int var14 = 0; var14 < var13; var14++) {
            int var15 = var2.get(MemorySegmentUtil.INT_BE, var5);
            int var16 = var2.get(MemorySegmentUtil.INT_BE, var5 + 4);
            int var17 = var2.get(MemorySegmentUtil.INT_BE, var5 + 8);
            FragileBlock var11 = new FragileBlock();
            var11.deserialize(var2, var5 + 12, var3);
            this.blockFragilityMap.put(new Vector3i(var15, var16, var17), var11);
            var5 += 16;
         }
      }
   }

   class="kw">public byte[] serialize() {
      byte[] var1 = new byte[5 + this.blockHealthMap.size() * 24 + 4 + this.blockFragilityMap.size() * 16];
      MemorySegment var2 = MemorySegment.ofArray(var1);
      var2.set(ValueLayout.JAVA_BYTE, 0L, (byte)2);
      var2.set(MemorySegmentUtil.INT_BE, 1L, this.blockHealthMap.size());
      int var3 = 5;

      for (Entry var5 : this.blockHealthMap.entrySet()) {
         Vector3i var6 = var5.getKey();
         var2.set(MemorySegmentUtil.INT_BE, var3, var6.x);
         var2.set(MemorySegmentUtil.INT_BE, var3 + 4, var6.y);
         var2.set(MemorySegmentUtil.INT_BE, var3 + 8, var6.z);
         BlockHealth var7 = var5.getValue();
         var7.serialize(var2, var3 + 12);
         var3 += 24;
      }

      var2.set(MemorySegmentUtil.INT_BE, var3, this.blockFragilityMap.size());
      var3 += 4;

      for (Entry var10 : this.blockFragilityMap.entrySet()) {
         Vector3i var11 = var10.getKey();
         var2.set(MemorySegmentUtil.INT_BE, var3, var11.x);
         var2.set(MemorySegmentUtil.INT_BE, var3 + 4, var11.y);
         var2.set(MemorySegmentUtil.INT_BE, var3 + 8, var11.z);
         FragileBlock var12 = var10.getValue();
         var12.serialize(var2, var3 + 12);
         var3 += 16;
      }

      class="kw">return var1;
   }
}