package unique.network.utilties.managers;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.OfflinePlayer;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;

import unique.network.UHC;
import unique.network.teams.Team;
import unique.network.utilties.chat.Color;

import java.util.*;

@SuppressWarnings("all")
public class TeamManager implements Listener {

    private static TeamManager instance = new TeamManager();
    private boolean teamsEnabled = false;
    private boolean damageTeamMembers = true;
    public static final Map<UUID, Team> teams = new HashMap<>();
    private int maxSize = 2;
    private int currentTeams = 0;
    private final String prefix = ChatColor.translateAlternateColorCodes('&', UHC.getInstance().getConfig().getString("settings.teams-prefix"));


    public static TeamManager getInstance() {
        return instance;
    }

    public boolean canDamageTeamMembers() {
        return damageTeamMembers;
    }

    public void setCanDamageTeamMembers(boolean damageTeamMembers) {
        this.damageTeamMembers = damageTeamMembers;
    }

    public boolean isTeamsEnabled() {
        return teamsEnabled;
    }

    public void setTeamsEnabled(boolean teamsEnabled) {
        this.teamsEnabled = teamsEnabled;
    }

    public void clearTeams() {
        teams.clear();
        for (UUID uuid : teams.keySet()) {
            unregisterTeam(uuid);
        }

        currentTeams = 0;
    }

    public void unregisterTeam(UUID uuid) {
        teams.get(uuid).removePlayer(Bukkit.getOfflinePlayer(uuid));
        teams.remove(uuid);
    }

    public Map<UUID, Team> getTeams() {
        return teams;
    }

    public void autoPlace() {
        for (Player players : Bukkit.getServer().getOnlinePlayers()) {
            Team team = teams.get(players.getUniqueId());
            if (team == null) {
                createTeam(players);
            }
        }
    }

    public void createTeam(Player owner) {
        currentTeams++;
        Team currentTeam = teams.get(owner.getUniqueId());
        if (currentTeam != null) {
            currentTeam.removePlayer(owner);
        }
        registerTeam(owner, new Team(owner, currentTeams));
    }

    public void registerTeam(Player player, Team team) {
        if (team.getSize() == getMaxSize()) {
            player.sendMessage(Color.translate("&4&lWARNING: &fTeam Size is currently set to &a" + maxSize));
            return;
        }
        team.addPlayer(player);
        teams.put(player.getUniqueId(), team);
    }

    public void disbandTeam(Team team) {
        for (UUID uuid : team.getPlayers()) {
            unregisterTeam(uuid);
        }
    }

    public int getMaxSize() {
        return this.maxSize;
    }

    public void setMaxSize(int maxSize) {
        this.maxSize = maxSize;
    }

    public Set<Team> getTeamSet() {
        Set<Team> teams = new HashSet<>();
        teams.addAll(TeamManager.teams.values());
        return teams;
    }

    public int getTeamsAlive() {
        int i = 0;
        for (Team team : getTeamSet()) {
            if (team.isAlive()) {
                i++;
            }
        }
        return i;
    }

    public String getTeamsPrefix() {
        return prefix;
    }

    public Team getLastTeam() {
        if (getTeamsAlive() == 1) {
            for (Team teams : getTeamSet()) {
                if (teams.isAlive()) {
                    return teams;
                }
            }
        }
        return null;
    }

    public Team getTeam(OfflinePlayer player) {
        return TeamManager.getInstance().getTeams().get(player.getUniqueId());
    }
}