package com.lifeknight.relaymcbungeemain.queue;

import com.lifeknight.relaymcbungeemain.player.SmartPlayer;
import com.lifeknight.relaymcbungeemain.utilities.Server;
import com.lifeknight.relayutils.data.QueueData;
import com.lifeknight.relayutils.game.GameDetails;
import com.lifeknight.relayutils.game.GameType;
import com.lifeknight.relayutils.game.MainGame;
import com.lifeknight.relayutils.network.Recipient;
import com.lifeknight.relayutils.utilities.ComponentBuilder;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.chat.BaseComponent;
import net.md_5.bungee.api.chat.TextComponent;
import net.md_5.bungee.api.config.ServerInfo;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class GameServer {
    public static final List<GameServer> GAME_SERVERS = new ArrayList<>();

    public final List<UUID> markedQueueUUIDs = new ArrayList<>();

    private final ServerInfo serverInfo;
    private final Recipient recipient;
    private final ServerDetails serverDetails;
    public boolean online = true;

    public GameServer(ServerInfo serverInfo, ServerDetails serverDetails) {
        this.serverInfo = serverInfo;
        this.recipient = Recipient.getRecipient(serverInfo.getName());
        this.serverDetails = serverDetails;
        GAME_SERVERS.add(this);
    }

    public static void onUnavailable(Recipient senderRecipient) {
        GameServer gameServer = getGameServer(senderRecipient);
        if (gameServer != null) {
            gameServer.online = false;
            gameServer.getServer().setAvailableForPlayers(false);
        }
    }

    public static BaseComponent getGameServersMessage() {
        BaseComponent baseComponent = new TextComponent();

        for (GameServer gameServer : GAME_SERVERS) {
            baseComponent.addExtra(gameServer.getComponent());
        }

        return baseComponent;
    }

    public static int getPlayersInGame() {
        int count = 0;
        for (GameServer gameServer : GAME_SERVERS) {
            count += gameServer.getTotalPlayers();
        }
        return count;
    }

    public static List<QueueData> getGameData() {
        List<QueueData> data = new ArrayList<>();
        for (GameServer gameServer : GAME_SERVERS) {
            for (GameDetails gameDetail : gameServer.getServerDetails().gameDetails) {
                if (gameDetail.getPlayerCount() == 2 && gameDetail.getGameType() != null &&  !gameDetail.getQueueData().isParty()) {
                    gameDetail.getQueueData().attachData("gameType", gameDetail.getGameType());
                    data.add(gameDetail.getQueueData());
                }
            }
        }

        return data;
    }

    public static GameServer findRejoin(UUID uuid) {
        for (GameServer gameServer : GAME_SERVERS) {
            for (GameDetails gameDetail : gameServer.getServerDetails().gameDetails) {
                if (gameDetail.getQueueData().hasData("rejoinPlayers")) {
                    if (gameDetail.getQueueData().getData("rejoinPlayers").contains(uuid.toString())) {
                        return gameServer;
                    }
                }
            }
        }

        return null;
    }

    public int getTotalPlayers() {
        return this.getServer().getPlayerCount();
    }

    public boolean isAvailable(GameType gameType, List<SmartPlayer> smartPlayers) {
        return this.serverDetails.isAvailable(gameType, smartPlayers, this.markedQueueUUIDs);
    }

    public GameDetails getAvailable(GameType gameType, List<SmartPlayer> smartPlayers) {
        return this.serverDetails.getAvailable(gameType, smartPlayers, this.markedQueueUUIDs);
    }

    public ServerInfo getServerInfo() {
        return this.serverInfo;
    }

    public Recipient getRecipient() {
        return this.recipient;
    }

    public UUID getBestQueue(GameType gameType, List<SmartPlayer> smartPlayers) {
        return this.getAvailable(gameType, smartPlayers).getUUID();
    }

    public static GameServer getGameServer(Recipient recipient) {
        for (GameServer gameServer : GAME_SERVERS) {
            if (gameServer.recipient.equals(recipient)) {
                return gameServer;
            }
        }
        return null;
    }

    public boolean online() {
        return this.online && this.getServerInfo() != null;
    }

    public void markQueue(UUID queueUUID) {
        this.markedQueueUUIDs.add(queueUUID);
    }

    public void onDetailsUpdate() {
        for (GameDetails gameDetail : this.serverDetails.gameDetails) {
            if (gameDetail.isAvailable()) {
                this.markedQueueUUIDs.remove(gameDetail.getUUID());
            }
        }
    }

    public boolean match(GameType gameType) {
        Server server = this.getServer();
        MainGame serverMain = server.getMainGame();
        MainGame gameMain = gameType.getMainGame();
        return !server.isHub() && (serverMain == gameMain || (gameMain == MainGame.PARTY && serverMain == MainGame.MANHUNT));
    }

    public Server getServer() {
        return Server.getServer(this.serverInfo);
    }

    public ServerDetails getServerDetails() {
        return this.serverDetails;
    }

    @Override
    public String toString() {
        StringBuilder stringBuilder = new StringBuilder(ChatColor.AQUA.toString()).append("------ ").append(this.recipient.getName()).append(" ------").append("\n");
        return stringBuilder.append(this.serverDetails.format()).toString();
    }

    public BaseComponent getComponent() {
        ComponentBuilder componentBuilder = new ComponentBuilder();
        componentBuilder.color(ComponentBuilder.AQUA).append(this.recipient.getName());
        componentBuilder.appendComponent(this.serverDetails.getComponent());

        return componentBuilder.getResult();
    }
}