@EventBusSubscriber(modid = HugMe.MODID, value = Dist.CLIENT, bus = EventBusSubscriber.Bus.GAME)
public class RenderPlayerEventHandler {
    private static final Minecraft client = Minecraft.getInstance();
    private static final Map<UUID, UUID> playerLockMap = new HashMap<>();
    private static final Map<UUID, Boolean> playerLockState = new HashMap<>();

    @SubscribeEvent
    public static void onRenderPlayer(RenderPlayerEvent.Pre event) {
        Player player = event.getEntity();
        PlayerRenderer renderer = event.getRenderer();
        float partialTicks = event.getPartialTick();
        PoseStack poseStack = event.getPoseStack();
        MultiBufferSource buffer = event.getMultiBufferSource();
        int packedLight = event.getPackedLight();

        if (player instanceof AbstractClientPlayer clientPlayer) {
            UUID playerId = player.getUUID();
            if (playerLockMap.containsKey(playerId)) {
                UUID targetPlayerUUID = playerLockMap.get(playerId);
                if (targetPlayerUUID == null) return;
                if (client.level == null) return;
                AbstractClientPlayer targetPlayer = (AbstractClientPlayer) client.level.getPlayerByUUID(targetPlayerUUID);
                if (targetPlayer == null) return;
                float targetYaw = calculateYawToTarget(clientPlayer, targetPlayer);

                poseStack.pushPose();

                poseStack.mulPose(Axis.XP.rotationDegrees(180.0F));
                poseStack.translate(0, -1.5, 0);
                poseStack.mulPose(new org.joml.Quaternionf().rotationY((float) Math.toRadians(targetYaw)));
                renderPlayerModel(renderer, clientPlayer, partialTicks, poseStack, buffer, packedLight);

                poseStack.popPose();
                event.setCanceled(true);
            }
        }
    }

    private static void renderPlayerModel(PlayerRenderer renderer, AbstractClientPlayer entity, float partialTicks, PoseStack poseStack, MultiBufferSource buffer, int packedLight) {
        PlayerModel<AbstractClientPlayer> model = renderer.getModel();
        model.young = entity.isBaby();

        if (entity == client.player && client.options.getCameraType() == CameraType.FIRST_PERSON) {
            model.head.visible = false;
        }

        model.setupAnim(entity, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F);
        RenderType renderType = RenderType.entityCutoutNoCull(renderer.getTextureLocation(entity));

        model.renderToBuffer(poseStack, buffer.getBuffer(renderType), packedLight, OverlayTexture.NO_OVERLAY, -1);
    }

    private static float calculateYawToTarget(AbstractClientPlayer fromPlayer, AbstractClientPlayer toPlayer) {
        double deltaX = toPlayer.getX() - fromPlayer.getX();
        double deltaZ = toPlayer.getZ() - fromPlayer.getZ();
        return (float) Math.toDegrees(Math.atan2(deltaZ, deltaX)) - 90.0F;
    }

    public static void lockPlayers(AbstractClientPlayer player1, AbstractClientPlayer player2) {
        playerLockMap.put(player1.getUUID(), player2.getUUID());
        playerLockMap.put(player2.getUUID(), player1.getUUID());
        playerLockState.put(player1.getUUID(), true);
        playerLockState.put(player2.getUUID(), true);
        HugMe.LOGGER.debug("Locked " + player1.getName().getString() + " and " + player2.getName().getString());
    }

    public static void unlockPlayers(AbstractClientPlayer player1, AbstractClientPlayer player2) {
        playerLockMap.remove(player1.getUUID());
        playerLockMap.remove(player2.getUUID());
        playerLockState.remove(player1.getUUID());
        playerLockState.remove(player2.getUUID());
        HugMe.LOGGER.debug("Unlocked " + player1.getName().getString() + " and " + player2.getName().getString());
    }

    public static boolean isPlayerLocked(AbstractClientPlayer player) {
        return playerLockState.getOrDefault(player.getUUID(), false);
    }
}