package hdvtdev.blockAndSeek;

import hdvtdev.blockAndSeek.managers.FreezeManager;
import me.libraryaddict.disguise.DisguiseAPI;
import org.bukkit.Bukkit;
import org.bukkit.GameMode;
import org.bukkit.Location;
import org.bukkit.entity.Player;
import org.bukkit.persistence.PersistentDataType;

import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicBoolean;

public class BlockAndSeekGame {

    private final ConcurrentHashMap<Player, PlayerType> players = new ConcurrentHashMap<>();

    private final AtomicBoolean started = new AtomicBoolean(false);
    private final String name;
    private final int maxPlayers;
    private final Location lobby;


    public BlockAndSeekGame(String name, int maxPlayers, List<Integer> lobby) {
        this.name = name;
        this.maxPlayers = maxPlayers;
        this.lobby = new Location(Bukkit.getWorld(name), lobby.getFirst(), lobby.get(1), lobby.get(2));
    }

    public List<Player> getHiders() {
        return players.entrySet().stream().filter(e -> Objects.equals(e.getValue(), PlayerType.HIDER)).map(Map.Entry::getKey).toList();
    }

    public void preEnd() {

        for (Player hider : getHiders()) {
            FreezeManager.unfreezeIfFrozen(hider);
            FreezeManager.removePlayerDisguise(hider);
            DisguiseAPI.undisguiseToAll(hider);
            hider.getInventory().clear();
            hider.setGlowing(true);
        }

        for (Player player : getPlayers()) {
            player.setInvulnerable(true);
            player.setVisibleByDefault(true);
        }


    }

    public void end() {

        for (Player hider : getHiders()) {
            FreezeManager.removePlayerDisguise(hider);
            DisguiseAPI.undisguiseToAll(hider);
        }

        for (Player player : players.keySet()) {
            player.teleport(lobby);
            player.getPersistentDataContainer().remove(Keys.PLAYER);
            player.setGameMode(GameMode.SURVIVAL);
            player.setInvulnerable(false);
            player.setGlowing(false);
        }
    }

    public boolean addPlayer(Player player) {
        if (started.get() || playerCount() + 1 > maxPlayers) {
            return false;
        }
        player.getPersistentDataContainer().set(Keys.PLAYER, PersistentDataType.STRING, name);
        player.teleport(lobby);
        players.put(player, PlayerType.HIDER);
        return true;
    }

    public void removePlayer(Player player) {
        players.remove(player);
    }

    public void setSpectator(Player player) {
        players.put(player, PlayerType.SPECTATOR);
        player.setGameMode(GameMode.SPECTATOR);
    }

    public Set<Player> getPlayers() {
        return players.keySet();
    }

    public Player getLastHider() {
        for (Map.Entry<Player, PlayerType> entry : players.entrySet()) {
            if (entry.getValue() == PlayerType.HIDER) return entry.getKey();
        }
        return null;
    }

    public int seekersCount() {
        return (int) players.values().stream().filter(f -> f.equals(PlayerType.SEEKER)).count();
    }

    public int hidersCount() {
        return (int) players.values().stream().filter(f -> f.equals(PlayerType.HIDER)).count();
    }

    public int playerCount() {
        return players.size();
    }

    public void start() {
        started.set(true);
    }

    public boolean isStarted() {
        return started.get();
    }

    public Player selectRandomSeeker() {
        return selectRandomSeekers(1).getFirst();
    }

    public List<Player> selectRandomSeekers(int count) {
        ArrayList<Player> playerList = new ArrayList<>(players.keySet());
        Collections.shuffle(playerList);
        List<Player> seekers = playerList.subList(0, Math.min(count, playerList.size()));
        for (Player seeker : seekers) players.put(seeker, PlayerType.SEEKER);
        return seekers;
    }

    private enum PlayerType {
        SEEKER,
        HIDER,
        SPECTATOR
    }


}