SleepingPlayerUtils

package com.mystanica.dreamlands.handler.util;

import com.mystanica.dreamlands.common.data.level.DreamlandsPlayerEntry;
import com.mystanica.dreamlands.common.data.level.DreamlandsSavedData;
import com.mystanica.dreamlands.common.data.level.player.SleepingPlayerData;
import com.mystanica.dreamlands.common.entity.misc.SleepingPlayer;
import com.mystanica.dreamlands.common.worldgen.PortalTeleporter;
import com.mystanica.dreamlands.init.DreamEntities;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.server.level.ServerLevel;
import net.minecraft.world.entity.Entity;
import net.minecraft.world.entity.LivingEntity;
import net.minecraft.world.entity.player.Player;

import javax.annotation.Nullable;
import java.util.UUID;
import java.util.function.Consumer;

public class SleepingPlayerUtils {

    /**
     * create a sleeping player based from the actual player when they enter a dream.
     *
     * @param player - create the sleeping player from this player.
     */
    public static void createPlayersSleepingPlayer(ServerLevel level, Player player) {
        DreamlandsSavedData savedData = DreamlandsSavedData.getData(level);
        DreamlandsPlayerEntry playerEntry = savedData.getPlayerById(player.getUUID());

        /// create a new player entry if they do not exist already.
        if (playerEntry == null) {
            playerEntry = new DreamlandsPlayerEntry(new CompoundTag());
            playerEntry.setPlayerId(player.getUUID());

            savedData.getPlayers().put(player.getUUID(), playerEntry); /// add the player entry into the overworld data.
            savedData.setChanged();
        }

        SleepingPlayerData playerData = playerEntry.getPlayerData();
        if (playerData == null) {
            playerData = createSleepingPlayerData(player);
            playerEntry.savePlayerData(playerData);
            savedData.setChanged();
        }

        if (getSleepingPlayer(level, playerData.getSleepingPlayersId()) == null) {
            spawnSleepingPlayer(level, player, playerData);
            System.out.println("    created");
        }
    }

    private static SleepingPlayerData createSleepingPlayerData(Player player) {
        SleepingPlayerData playerData = new SleepingPlayerData(new CompoundTag());
        playerData.setProfileFromPlayer(player.getGameProfile());
        playerData.setSavedDataFromPlayer(player.saveWithoutId(new CompoundTag()));
        playerData.setSleepingPlayersId(UUID.randomUUID());

        player.getSleepingPos().ifPresent(playerData::setSleepingPos);
        return playerData;
    }

    public static void removePlayersSleepingPlayer(ServerLevel level, Player player) {
        DreamlandsSavedData savedData = DreamlandsSavedData.getData(level);
        DreamlandsPlayerEntry playerEntry = savedData.getPlayerById(player.getUUID());

        if (playerEntry != null) {
            SleepingPlayerData playerData = playerEntry.getPlayerData();

            if (playerData != null) {
                getSleepingPlayer(level, playerData.getSleepingPlayersId(), sleepingPlayer -> {
                    player.startSleeping(playerData.getSleepingPos());
                    player.stopSleeping();

                    sleepingPlayer.remove(Entity.RemovalReason.DISCARDED);
                    System.out.println("    removed");
                });

                playerEntry.clearPlayerData(); /// remove the data from the saved data.
                savedData.setChanged();
            }
        }
    }

    public static void unloadSleepingPlayer(ServerLevel level, Player player) {
        DreamlandsSavedData savedData = DreamlandsSavedData.getData(level);
        DreamlandsPlayerEntry playerEntry = savedData.getPlayerById(player.getUUID());

        if (playerEntry != null) {
            SleepingPlayerData playerData = playerEntry.getPlayerData();

            if (playerData != null) {
                getSleepingPlayer(level, playerData.getSleepingPlayersId(), sleepingPlayer -> {
                    sleepingPlayer.remove(Entity.RemovalReason.UNLOADED_WITH_PLAYER);
                    System.out.println("    unloaded");
                });
            }
        }
    }

    public static void reloadSleepingPlayer(ServerLevel level, Player player) {
        DreamlandsSavedData savedData = DreamlandsSavedData.getData(level);
        DreamlandsPlayerEntry playerEntry = savedData.getPlayerById(player.getUUID());

        if (playerEntry != null) {
            SleepingPlayerData playerData = playerEntry.getPlayerData();

            if (playerData != null) {
                if (getSleepingPlayer(level, playerData.getSleepingPlayersId()) == null) {
                    spawnSleepingPlayer(level, player, playerData);
                    System.out.println("    reloaded");
                }
            }
        }
    }

    private static void spawnSleepingPlayer(ServerLevel level, Player player, SleepingPlayerData playerData) {
        SleepingPlayer sleepingPlayer = DreamEntities.SLEEPING_PLAYER.get().create(level);
        if (sleepingPlayer == null) {
            return;
        }

        sleepingPlayer.load(playerData.getPlayerData());
        sleepingPlayer.setGameProfile(playerData.getPlayerProfile());
        sleepingPlayer.setUUID(playerData.getSleepingPlayersId());
        sleepingPlayer.setCustomName(player.getName());
        sleepingPlayer.setSleepingPos(playerData.getSleepingPos());
        sleepingPlayer.copyPosition(player);

        level.addFreshEntity(sleepingPlayer);
    }

    public static void getSleepingPlayer(ServerLevel level, UUID uuid, Consumer<SleepingPlayer> consumer) {
        SleepingPlayer sleepingPlayer = getSleepingPlayer(level, uuid);

        if (sleepingPlayer != null) {
            consumer.accept(sleepingPlayer);
        }
    }

    /**
     * @param level - this needs to be the overworld, as the data is always saved in it.
     * @param uuid -- the uuid of the sleeping player; grabbed from the players' overworld saved data.
     *
     * @return either the sleeping player, or null.
     */
    @Nullable
    public static SleepingPlayer getSleepingPlayer(ServerLevel level, UUID uuid) {
        Entity entity = level.getEntity(uuid);
        if (entity instanceof SleepingPlayer sleepingPlayer) {
            return sleepingPlayer;
        }

        return null;
    }

    @Nullable
    public static Player getPlayerFromSleepingPlayer(SleepingPlayer sleepingPlayer) {
        if (sleepingPlayer.getServer() != null && sleepingPlayer.getGameProfile() != null) {
            UUID uuid = sleepingPlayer.getGameProfile().getId();
            return sleepingPlayer.getServer().getPlayerList().getPlayer(uuid);
        }

        return null;
    }

    public static <T extends LivingEntity> void sendToDimension(T entity, ServerLevel destination) {
        if (entity instanceof Player player) {
            player.changeDimension(destination, new PortalTeleporter());
        }
    }

}