package hdvtdev.blockAndSeek;

import me.libraryaddict.disguise.DisguiseAPI;
import org.bukkit.GameMode;
import org.bukkit.Material;
import org.bukkit.entity.Player;
import org.bukkit.persistence.PersistentDataType;

import java.security.SecureRandom;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
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;


    public BlockAndSeekGame(String name, int maxPlayers) {
        this.name = name;
        this.maxPlayers = maxPlayers;
    }

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

    public void end() {
        for (Player player : players.keySet()) {
            //EventListener.unfreezePlayer(player); TODO
            player.getPersistentDataContainer().remove(BlockAndSeekContainer.PLAYER);
            player.sendBlockChange(player.getLocation(), Material.AIR.createBlockData());
            player.setGameMode(GameMode.SURVIVAL);
            DisguiseAPI.undisguiseToAll(player);
        }
    }

    public boolean addPlayer(Player player) {
        if (started.get() || playerCount() + 1 > maxPlayers) {
            return false;
        }
        player.getPersistentDataContainer().set(BlockAndSeekContainer.PLAYER, PersistentDataType.STRING, name);
        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() {
        SecureRandom random = new SecureRandom();
        int i = 0;
        int randomNum = random.nextInt(0, players.size());
        for (Player player : players.keySet()) {
            if (i == randomNum) {
                players.put(player, PlayerType.SEEKER);
                return player;
            }
            i++;
        }
        return null;
    }

    private enum PlayerType {
        SEEKER,
        HIDER,
        SPECTATOR
    }


}