CometSkyBlock/plugin/src/main/java/com/alttd/cometskyblock/island/Island.java

package com.alttd.cometskyblock.island;

import com.alttd.cometskyblock.CometSkyBlockPlugin;
import com.alttd.cometskyblock.island.oregenerator.GeneratorTier;
import com.alttd.cometskyblock.records.IslandRecord;
import com.alttd.cometskyblock.request.Request;
import lombok.Getter;
import lombok.Setter;
import net.kyori.adventure.text.minimessage.tag.resolver.TagResolver;
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.potion.PotionEffect;
import org.bukkit.potion.PotionEffectType;

import java.io.File;
import java.util.*;
import java.util.stream.Collectors;

public class Island extends YamlConfiguration {

    private static final Map<UUID, Island> configs = new HashMap<>();
    public static final UUID NILL_UUID = new UUID(0L, 0L);

    public static Island getIsland(UUID uuid) {
        synchronized (configs) {
            return configs.computeIfAbsent(uuid, k -> new Island(uuid));
        }
    }

    public static Island loadIslandFromFile(File file) {
        return new Island(file);
    }

    public static void remove(UUID uuid) {
        synchronized (configs) {
            configs.remove(uuid);
        }
    }

    public static void removeAll() {
        synchronized (configs) {
            configs.clear();
        }
    }

    private final File file;
    private final Object saveLock = new Object();
    @Getter private final UUID islandUUID;
    @Getter @Setter private Request request;

    private Island(UUID uuid) {
        super();
        this.islandUUID = uuid;
        this.file = new File(CometSkyBlockPlugin.instance().getDataFolder(), "IslandData" + File.separator + uuid + ".yml");
        reload();
    }

    private Island(File file) {
        this.islandUUID = Island.NILL_UUID;
        this.file = file;
        reload();
    }

    public static Collection<Island> getIslands() {
        return configs.values();
    }

    private void reload() {
        synchronized (saveLock) {
            try {
                load(file);
            } catch (Exception ignore) {
            }
        }
    }

    private void save() {
        synchronized (saveLock) {
            try {
                save(file);
            } catch (Exception ignore) {
            }
        }
    }

    public int islandId() {
        return getInt("island.id", 0);
    }

    public void islandId(int id) {
        set("island.id", id);
        save();
    }

    public String worldName() {
        return getString("island.worldname");
    }

    public void worldName(String worldName) {
        set("island.worldname", worldName);
        save();
    }

    public String islandName() {
        return getString("island.islandname", "Unnamed Island");
    }

    public void islandName(String islandName) {
        IslandData.updateIsland(new IslandData(islandId(), islandName, level()));
        set("island.islandname", islandName);
        save();
    }

    public int level() {
        return getInt("island.level", 0);
    }

    public void level(int level) {
        IslandData.updateIsland(new IslandData(islandId(), islandName(), level));
        set("island.level", level);
        save();
    }

    public UUID owner() {
        String string = getString("island.owner");
        if (string == null || string.isEmpty())
            return NILL_UUID;

        return UUID.fromString(string);
    }

    public void owner(UUID uuid) {
        set("island.owner", uuid.toString());
        String islandName = islandName();
        if ((islandName == null || islandName.isBlank()) && !uuid.equals(NILL_UUID)) {
            islandName(Bukkit.getOfflinePlayer(uuid).getName() + "'s island");
        }
        save();
    }

    public List<UUID> members() {
        List<String> members = getStringList("island.members");
        return members.stream()
                .map(this::stringToUUID)
                .collect(Collectors.toList());
    }

    public void members(List<UUID> members) {
        set("island.members", members.stream()
                .map(uuid -> uuid == null ? "null" : uuid.toString())
                .collect(Collectors.toList()));
        save();
    }

    private String uuidToString(UUID uuid) {
        return (uuid == null ? NILL_UUID : uuid).toString();
    }

    private UUID stringToUUID(String s) {
        return s == null || s.isEmpty() ? NILL_UUID : UUID.fromString(s);
    }

    public boolean canBuild(UUID uuid) {
        return owner().equals(uuid) || members().contains(uuid);
    }

    public void addMember(UUID uuid) {
        IslandPlayer islandPlayer = IslandPlayer.getIslandPlayer(uuid);
        islandPlayer.islandId(islandId());
        islandPlayer.islandUUID(islandUUID());
        List<UUID> list = members();
        list.add(uuid);
        members(list);
    }

    public void removeMember(UUID uuid) {
        List<UUID> list = members();
        list.remove(uuid);
        members(list);
    }

    // TODO - Island settings
    public boolean visitNeedsRequest() {
        return true;
    }

    public int worldBorderLevel() {
        return getInt("island.worldborder.level", 0);
    }

    public void worldBorderLevel(int level) {
        set("island.worldborder.level", level);
        save();
    }

    public void teleport(Player player) {
        World islandWorld = CometSkyBlockPlugin.instance().worldGenerator().loadIslandWorld(worldName());
        if (islandWorld == null) {
            player.sendRichMessage("<red>Could not load islandWorld. Contact an administrator");
            return;
        }
        teleport(player, islandWorld.getSpawnLocation());
    }

    public void teleport(Player player, Location location) {
        PotionEffect potionEffectBlindness = new PotionEffect(PotionEffectType.BLINDNESS, 600, 1);
        PotionEffect potionEffectNightVision = new PotionEffect(PotionEffectType.NIGHT_VISION, 600, 1);
        player.addPotionEffect(potionEffectBlindness);
        player.addPotionEffect(potionEffectNightVision);
        World islandWorld = CometSkyBlockPlugin.instance().worldGenerator().loadIslandWorld(location.getWorld().getName());
        if (islandWorld == null) {
            player.sendRichMessage("<red>Could not load islandWorld. Contact an administrator");
            player.removePotionEffect(PotionEffectType.BLINDNESS);
            player.removePotionEffect(PotionEffectType.NIGHT_VISION);
            return;
        }

        player.teleportAsync(location).whenComplete((b, e) -> {
            player.removePotionEffect(PotionEffectType.BLINDNESS);
            player.removePotionEffect(PotionEffectType.NIGHT_VISION);
        });
    }

    public void broadCast(String message, TagResolver placeholder) {
        Player islandOwner = Bukkit.getPlayer(owner());
        if (islandOwner != null)
            islandOwner.sendMiniMessage(message, placeholder);

        for (UUID uuid : members()) {
            Player islandMember = Bukkit.getPlayer(uuid);
            if (islandMember == null)
                continue;

            islandMember.sendMiniMessage(message, placeholder);
        }
    }

    public IslandRecord toRecord() {
        return new IslandRecord(islandId(), islandName(), level());
    }


    public int challengeCount(String key) {
        return getInt("challenges." + key, 0);
    }

    public void challengeCount(String key, int amount) {
        set("challenges." + key, amount);
        save();
    }

    public int oreGeneratorLevel(GeneratorTier generatorTier) {
        return getInt("generator-level." + generatorTier.toString().toLowerCase(), 0);
    }

    public void oreGeneratorLevel(GeneratorTier generatorTier, int level) {
        set("generator-level." + generatorTier.toString().toLowerCase(), level);
        save();
    }

    public boolean unlockedGeneratorTier(GeneratorTier generatorTier) {
        switch (generatorTier) {
            case COBBLESTONE, BASALT -> {
                return true;
            }
        }
        return contains("generator-level." + generatorTier.toString().toLowerCase(), true);
    }
}