class="kw">package com.hypixel.hytale.builtin.instances.interactions;

class="kw">import com.hypixel.hytale.assetstore.map.IndexedLookupTableAssetMap;
class="kw">import com.hypixel.hytale.builtin.instances.InstanceValidator;
class="kw">import com.hypixel.hytale.builtin.instances.InstancesPlugin;
class="kw">import com.hypixel.hytale.builtin.instances.blocks.InstanceBlock;
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.validation.Validators;
class="kw">import com.hypixel.hytale.common.util.CompletableFutureUtil;
class="kw">import com.hypixel.hytale.component.AddReason;
class="kw">import com.hypixel.hytale.component.Archetype;
class="kw">import com.hypixel.hytale.component.CommandBuffer;
class="kw">import com.hypixel.hytale.component.ComponentAccessor;
class="kw">import com.hypixel.hytale.component.Holder;
class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.component.Store;
class="kw">import com.hypixel.hytale.math.Axis;
class="kw">import com.hypixel.hytale.math.shape.Box;
class="kw">import com.hypixel.hytale.math.util.ChunkUtil;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Transform;
class="kw">import com.hypixel.hytale.math.vector.Vector3dUtil;
class="kw">import com.hypixel.hytale.protocol.BlockPosition;
class="kw">import com.hypixel.hytale.protocol.InteractionType;
class="kw">import com.hypixel.hytale.protocol.WaitForDataFrom;
class="kw">import com.hypixel.hytale.server.core.asset.type.blockhitbox.BlockBoundingBoxes;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.RotationTuple;
class="kw">import com.hypixel.hytale.server.core.entity.InteractionContext;
class="kw">import com.hypixel.hytale.server.core.entity.entities.Player;
class="kw">import com.hypixel.hytale.server.core.modules.block.BlockModule;
class="kw">import com.hypixel.hytale.server.core.modules.entity.component.TransformComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.damage.DeathComponent;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.PendingTeleport;
class="kw">import com.hypixel.hytale.server.core.modules.entity.teleport.Teleport;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.CooldownHandler;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.OriginSource;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.SimpleInstantInteraction;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockChunk;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.BlockOperations;
class="kw">import com.hypixel.hytale.server.core.universe.world.chunk.WorldChunk;
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 java.util.UUID;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.concurrent.TimeUnit;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector3d;

class="kw">public class TeleportInstanceInteraction class="kw">extends SimpleInstantInteraction {
   @Nonnull
   class="kw">public class="kw">static class="kw">final BuilderCodec<TeleportInstanceInteraction> CODEC = BuilderCodec.builder(
         TeleportInstanceInteraction.class, TeleportInstanceInteraction::new, SimpleInstantInteraction.CODEC
      )
      .documentation("Teleports the **Player** to the named instance, creating it if required.")
      .<String>appendInherited(
         new KeyedCodec<>("InstanceName", Codec.STRING),
         (var0, var1) -> var0.instanceName = var1,
         var0 -> var0.instanceName,
         (var0, var1) -> var0.instanceName = var1.instanceName
      )
      .documentation("The name of the **instance** to teleport to.")
      .addValidator(Validators.nonNull())
      .addValidator(InstanceValidator.INSTANCE)
      .add()
      .<String>appendInherited(
         new KeyedCodec<>("InstanceKey", Codec.STRING),
         (var0, var1) -> var0.instanceKey = var1,
         var0 -> var0.instanceKey,
         (var0, var1) -> var0.instanceKey = var1.instanceKey
      )
      .documentation("The key to name the world. Random if not provided")
      .add()
      .<Vector3d>appendInherited(
         new KeyedCodec<>("PositionOffset", Vector3dUtil.CODEC),
         (var0, var1) -> var0.positionOffset = var1,
         var0 -> var0.positionOffset,
         (var0, var1) -> var0.positionOffset = var1.positionOffset
      )
      .documentation("The offset to apply to the class="kw">return point.\n\nUsed to prevent repeated interactions when returning from the instance.")
      .add()
      .<Rotation3f>appendInherited(
         new KeyedCodec<>("Rotation", Rotation3f.PARTIAL_TELEPORT_CODEC),
         (var0, var1) -> var0.rotation = var1,
         var0 -> var0.rotation,
         (var0, var1) -> var0.rotation = var1.rotation
      )
      .documentation("The rotation to set the player to when returning from an instance.")
      .add()
      .<OriginSource>appendInherited(
         new KeyedCodec<>("OriginSource", OriginSource.CODEC),
         (var0, var1) -> var0.originSource = var1,
         var0 -> var0.originSource,
         (var0, var1) -> var0.originSource = var1.originSource
      )
      .documentation("The source to use for the class="kw">return position.\n\nDefaults to the player's position.")
      .addValidator(Validators.nonNull())
      .add()
      .<Boolean>appendInherited(
         new KeyedCodec<>("PersonalReturnPoint", Codec.BOOLEAN),
         (var0, var1) -> var0.personalReturnPoint = var1,
         var0 -> var0.personalReturnPoint,
         (var0, var1) -> var0.personalReturnPoint = var1.personalReturnPoint
      )
      .documentation(
         "Whether the player entering the instance will have their own class="kw">return point\nset to the current location. Overriding the world's class="kw">return point."
      )
      .add()
      .<Boolean>appendInherited(
         new KeyedCodec<>("CloseOnBlockRemove", Codec.BOOLEAN),
         (var0, var1) -> var0.closeOnBlockRemove = var1,
         var0 -> var0.closeOnBlockRemove,
         (var0, var1) -> var0.closeOnBlockRemove = var1.closeOnBlockRemove
      )
      .documentation("Whether to delete the instance when the portal block is removed.")
      .add()
      .<Double>appendInherited(
         new KeyedCodec<>("RemoveBlockAfter", Codec.DOUBLE),
         (var0, var1) -> var0.removeBlockAfter = var1,
         var0 -> var0.removeBlockAfter,
         (var0, var1) -> var0.removeBlockAfter = var1.removeBlockAfter
      )
      .documentation(
         "The number of seconds to wait before removing the block that triggered\nthe interaction. A negative value disables this.\n\nThis is needed instead of using another interaction due to all interactions\nbeing stopped once teleporting to another world."
      )
      .add()
      .afterDecode(var0 -> {
         if (var0.rotation != null) {
            var0.rotation.mul((float) (Math.PI / 180.0));
         }
      })
      .build();
   class="kw">private class="kw">static class="kw">final int SET_BLOCK_SETTINGS = 256;
   class="kw">private String instanceName;
   class="kw">private String instanceKey;
   class="kw">private Vector3d positionOffset;
   class="kw">private Rotation3f rotation;
   @Nonnull
   class="kw">private OriginSource originSource = OriginSource.ENTITY;
   class="kw">private boolean personalReturnPoint;
   class="kw">private boolean closeOnBlockRemove = true;
   class="kw">private double removeBlockAfter = -1.0;

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

   @Nonnull
   @Override
   class="kw">public WaitForDataFrom getWaitForDataFrom() {
      class="kw">return WaitForDataFrom.Server;
   }

   @Override
   class="kw">protected void firstRun(@Nonnull InteractionType var1, @Nonnull InteractionContext var2, @Nonnull CooldownHandler var3) {
      CommandBuffer var4 = var2.getCommandBuffer();
      assert var4 != null;
      Ref var5 = var2.getEntity();
      DeathComponent var6 = var4.getComponent(var5, DeathComponent.getComponentType());
      if (var6 == null) {
         Player var7 = var4.getComponent(var5, Player.getComponentType());
         if (var7 != null && !var7.isWaitingForClientReady()) {
            Archetype var8 = var4.getArchetype(var5);
            if (!var8.contains(Teleport.getComponentType()) && !var8.contains(PendingTeleport.getComponentType())) {
               World var9 = var4.getExternalData().getWorld();
               InstancesPlugin var10 = InstancesPlugin.get();
               Universe var11 = Universe.get();
               CompletableFuture var13 = null;
               Transform var14 = null;
               World var12;
               if (this.instanceKey != null) {
                  var12 = var11.getWorld(this.instanceKey);
                  if (var12 == null) {
                     var14 = this.makeReturnPoint(var5, var2, var4);
                     var13 = var10.spawnInstance(this.instanceName, this.instanceKey, var9, var14);
                  }
               } else {
                  BlockPosition var15 = var2.getTargetBlock();
                  if (var15 == null) {
                     class="kw">return;
                  }

                  ChunkStore var16 = var9.getChunkStore();
                  Ref var17 = var16.getChunkSectionReferenceAtBlock(var15.x, var15.y, var15.z);
                  if (var17 == null || !var17.isValid()) {
                     class="kw">return;
                  }

                  int var18 = ChunkUtil.indexBlock(var15.x, var15.y, var15.z);
                  Ref var19 = BlockModule.getBlockEntity(var16.getStore(), var17, var15.x, var15.y, var15.z);
                  InstanceBlock var20;
                  if (var19 == null) {
                     Holder var21 = ChunkStore.REGISTRY.newHolder();
                     var20 = var21.ensureAndGetComponent(InstanceBlock.getComponentType());
                     var21.addComponent(BlockModule.BlockStateInfo.getComponentType(), new BlockModule.BlockStateInfo(var18, var17));
                     var19 = var16.getStore().addEntity(var21, AddReason.SPAWN);
                     var20.setCloseOnRemove(this.closeOnBlockRemove);
                  } else {
                     var20 = var16.getStore().getComponent(var19, InstanceBlock.getComponentType());
                  }

                  if (var19 == null) {
                     class="kw">return;
                  }

                  if (var20 == null) {
                     var20 = var16.getStore().ensureAndGetComponent(var19, InstanceBlock.getComponentType());
                     var20.setCloseOnRemove(this.closeOnBlockRemove);
                  }

                  UUID var31 = var20.getWorldUUID();
                  var13 = var20.getWorldFuture();
                  var12 = var31 != null ? var11.getWorld(var31) : null;
                  if (var12 == null && var13 == null) {
                     BlockModule.BlockStateInfo var22 = var16.getStore().getComponent(var19, BlockModule.BlockStateInfo.getComponentType());
                     var14 = this.makeReturnPoint(var5, var2, var4);
                     var13 = var10.spawnInstance(this.instanceName, var9, var14);
                     var20.setWorldFuture(var13);
                     Ref var23 = var19;
                     InstanceBlock var24 = var20;
                     CompletableFutureUtil._catch(var13.thenAcceptAsync(var3x -> {
                        if (var23.isValid()) {
                           var24.setWorldFuture(null);
                           var24.setWorldUUID(var3x.getWorldConfig().getUuid());
                           var22.markNeedsSaving();
                        }
                     }, var9));
                  }
               }

               if (var13 != null) {
                  Transform var25 = this.getPersonalReturnPoint(var5, var2, var14, var4);
                  InstancesPlugin.teleportPlayerToLoadingInstance(var5, var4, var13, var25);
               } else if (var12 != null) {
                  Transform var26 = this.getPersonalReturnPoint(var5, var2, var14, var4);
                  InstancesPlugin.teleportPlayerToInstance(var5, var4, var12, var26);
               }

               if (this.removeBlockAfter >= 0.0) {
                  BlockPosition var27 = var2.getTargetBlock();
                  if (var27 != null) {
                     if (this.removeBlockAfter == 0.0) {
                        ChunkStore var28 = var9.getChunkStore();
                        Ref var30 = var28.getChunkSectionReferenceAtBlock(var27.x, var27.y, var27.z);
                        if (var30 != null && var30.isValid()) {
                           BlockOperations.setBlock(var28, var30, var27.x, var27.y, var27.z, 0, BlockType.EMPTY, 0, 0, 256);
                        }
                     } else {
                        int var29 = var9.getBlock(var27.x, var27.y, var27.z);
                        new CompletableFuture().completeOnTimeout(null, (long)(this.removeBlockAfter * 1.0E9), TimeUnit.NANOSECONDS).thenRunAsync(() -> {
                           if (var9.getBlock(var27.x, var27.y, var27.z) == var29) {
                              ChunkStore var3 = var9.getChunkStore();
                              Ref var4 = var3.getChunkSectionReferenceAtBlock(var27.x, var27.y, var27.z);
                              if (var4 != null && var4.isValid()) {
                                 BlockOperations.setBlock(var3, var4, var27.x, var27.y, var27.z, 0, BlockType.EMPTY, 0, 0, 256);
                              }
                           }
                        }, var9);
                     }
                  }
               }
            }
         }
      }
   }

   @Nullable
   class="kw">private Transform getPersonalReturnPoint(
      @Nonnull Ref<EntityStore> var1, @Nonnull InteractionContext var2, @Nullable Transform var3, @Nonnull ComponentAccessor<EntityStore> var4
   ) {
      if (!this.personalReturnPoint) {
         class="kw">return null;
      } else {
         class="kw">return var3 == null ? this.makeReturnPoint(var1, var2, var4) : var3;
      }
   }

   @Nonnull
   class="kw">private Transform makeReturnPoint(@Nonnull Ref<EntityStore> var1, @Nonnull InteractionContext var2, @Nonnull ComponentAccessor<EntityStore> var3) {
      Transform var4 = null;
      class="kw">switch (this.originSource) {
         case ENTITY:
            TransformComponent var19 = var3.getComponent(var1, TransformComponent.getComponentType());
            assert var19 != null;
            var4 = new Transform(var19.getTransform());
            var4.getPosition().add(this.positionOffset);
            var4.setRotation(this.rotation != null ? this.rotation : Rotation3f.NaN);
            break;
         case BLOCK:
            BlockPosition var5 = var2.getTargetBlock();
            if (var5 == null) {
               throw new IllegalArgumentException("Can't use OriginSource.BLOCK without a target block");
            }

            World var6 = var3.getExternalData().getWorld();
            ChunkStore var7 = var6.getChunkStore();
            Store var8 = var7.getStore();
            Ref var9 = var7.getChunkReference(ChunkUtil.indexChunkFromBlock(var5.x, var5.z));
            if (var9 == null || !var9.isValid()) {
               throw new IllegalArgumentException("Missing chunk");
            }

            WorldChunk var10 = var8.getComponent(var9, WorldChunk.getComponentType());
            if (var10 == null) {
               throw new IllegalArgumentException("Missing chunk");
            }

            BlockType var11 = var10.getBlockType(var5.x, var5.y, var5.z);
            BlockChunk var12 = var8.getComponent(var9, BlockChunk.getComponentType());
            assert var12 != null;
            int var13 = var12.getSectionAtBlockY(var5.y).getRotationIndex(var5.x, var5.y, var5.z);
            RotationTuple var14 = RotationTuple.get(var13);
            IndexedLookupTableAssetMap var15 = BlockBoundingBoxes.getAssetMap();
            Box var16 = var15.getAsset(var11.getHitboxTypeIndex()).get(var13).getBoundingBox();
            Vector3d var17 = this.positionOffset != null ? var14.rotatedVector(this.positionOffset) : new Vector3d();
            var17.x = var17.x + (var16.middleX() + var5.x);
            var17.y = var17.y + (var16.middleY() + var5.y);
            var17.z = var17.z + (var16.middleZ() + var5.z);
            Rotation3f var18;
            if (this.rotation != null) {
               var18 = new Rotation3f(this.rotation);
               var18.addRotationOnAxis(Axis.Y, var14.yaw().getDegrees());
               var18.addRotationOnAxis(Axis.X, var14.pitch().getDegrees());
            } else {
               var18 = new Rotation3f(Rotation3f.NaN);
            }

            var4 = new Transform(var17, var18);
      }

      class="kw">return var4;
   }
}