package dev.loki.player;

import org.bukkit.entity.Player;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

public class PlayerManager {
    private final Map<UUID, BasePlayer> players;

    public PlayerManager() {
        this.players = new HashMap<>();
    }

    public void register(BasePlayer player) {
        players.put(player.getUuid(), player);
    }

    public void unregister(UUID uuid) {
        players.remove(uuid);
    }

    public BasePlayer getPlayer(UUID uuid) {
        return players.get(uuid);
    }

    public BasePlayer getPlayer(Player player) {
        return players.get(player.getUniqueId());
    }

    public boolean isRegistered(UUID uuid) {
        return players.containsKey(uuid);
    }

    public Collection<BasePlayer> getAllPlayers() {
        return players.values();
    }

    public Collection<Survivor> getSurvivors() {
        return players.values().stream()
            .filter(p -> !p.isKiller())
            .map(p -> (Survivor) p)
            .collect(Collectors.toList());
    }

    public Collection<Killer> getKillers() {
        return players.values().stream()
            .filter(BasePlayer::isKiller)
            .map(p -> (Killer) p)
            .collect(Collectors.toList());
    }

    public Killer getKiller() {
        return players.values().stream()
            .filter(BasePlayer::isKiller)
            .map(p -> (Killer) p)
            .findFirst()
            .orElse(null);
    }

    public Collection<Survivor> getLivingSurvivors() {
        return getSurvivors().stream()
            .filter(s -> s.getState() != PlayerState.DEAD && s.getState() != PlayerState.ESCAPED)
            .collect(Collectors.toList());
    }

    public int getLivingSurvivorCount() {
        return (int) getSurvivors().stream()
            .filter(s -> s.getState() != PlayerState.DEAD && s.getState() != PlayerState.ESCAPED)
            .count();
    }

    public void clear() {
        players.clear();
    }

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

    public Survivor findSurvivorByState(PlayerState state) {
        return getSurvivors().stream()
            .filter(s -> s.getState() == state)
            .findFirst()
            .orElse(null);
    }

    public Survivor getNearestSurvivor(Player from, double maxDistance) {
        Survivor nearest = null;
        double nearestDist = maxDistance;

        for (Survivor survivor : getLivingSurvivors()) {
            Player sPlayer = survivor.getPlayer();
            if (sPlayer == null || !sPlayer.isOnline()) continue;

            double dist = from.getLocation().distance(sPlayer.getLocation());
            if (dist < nearestDist) {
                nearestDist = dist;
                nearest = survivor;
            }
        }
        return nearest;
    }
}