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.request.Request;
import lombok.Getter;
import lombok.Setter;
import org.bukkit.World;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;

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 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 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");
    }

    public void islandName(String islandName) {
        set("island.islandname", islandName);
        save();
    }

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

    public void level(int id) {
        set("island.level", id);
        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());
        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()));
    }

    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 cobblegenLevel() {
        return getInt("island.generator.level", 0);
    }

    public void cobblegenLevel(int level) {
        set("island.generator.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;
        }

        player.teleportAsync(islandWorld.getSpawnLocation());
    }
}