package com.lifeknight.relaymcbungeemain.utilities;

import com.google.common.base.Preconditions;
import com.lifeknight.relaymcbungeemain.Main;
import com.lifeknight.relaymcbungeemain.player.ChatType;
import com.lifeknight.relaymcbungeemain.player.SmartPlayer;
import com.lifeknight.relaymcbungeemain.queue.GameServer;
import com.lifeknight.relaymcbungeemain.queue.PlayerGroup;
import com.lifeknight.relayutils.RelayUtils;
import com.lifeknight.relayutils.basic.Text;
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 io.netty.channel.unix.DomainSocketAddress;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.ProxyServer;
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 net.md_5.bungee.api.connection.ProxiedPlayer;

import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class Utilities {
    public static ProxiedPlayer getProxiedPlayer(String name) {
        if (name.length() > 16) return getProxiedPlayer(UUID.fromString(name));
        ProxiedPlayer proxiedPlayer = ProxyServer.getInstance().getPlayer(name);

        Preconditions.checkArgument(proxiedPlayer != null, "No player found: %s", name);

        return proxiedPlayer;
    }

    public static ProxiedPlayer getProxiedPlayer(UUID uuid) {
        ProxiedPlayer proxiedPlayer = ProxyServer.getInstance().getPlayer(uuid);

        Preconditions.checkArgument(proxiedPlayer != null, "No player found: %s", uuid);

        return proxiedPlayer;
    }

    public static ServerInfo getServerInfo(String name) {
        ServerInfo serverInfo = ProxyServer.getInstance().getServerInfo(name);

        Preconditions.checkArgument(serverInfo != null, "No server found: %s", name);

        return serverInfo;
    }

    public static GameServer getBestServer(GameType gameType, List<SmartPlayer> smartPlayers) {
        GameServer bestGameServer = null;
        GameDetails bestGameDetails = null;
        for (GameServer gameServer : GameServer.GAME_SERVERS) {
            if (gameServer.match(gameType) && gameServer.online() && gameServer.getServer().isViable(smartPlayers.size())) {
                GameDetails gameDetails = gameServer.getAvailable(gameType, smartPlayers);

                if (gameDetails != null) {
                    if (bestGameServer == null) {
                        bestGameServer = gameServer;
                        bestGameDetails = gameDetails;
                    } else {
                        if (gameDetails.getPlayerCount() > bestGameDetails.getPlayerCount()) {
                            bestGameServer = gameServer;
                            bestGameDetails = gameDetails;
                        }
                    }
                }
            }
        }

        if (bestGameServer == null && gameType.getMainGame() == MainGame.DUELS) {
            for (GameServer gameServer : GameServer.GAME_SERVERS) {
                if (gameServer.match(gameType) && gameServer.online() && gameServer.getTotalPlayers() + smartPlayers.size() < 32) {
                    GameDetails gameDetails = gameServer.getAvailable(gameType, smartPlayers);

                    if (gameDetails != null) {
                        if (bestGameServer == null) {
                            bestGameServer = gameServer;
                            bestGameDetails = gameDetails;
                        } else {
                            if (gameDetails.getPlayerCount() > bestGameDetails.getPlayerCount()) {
                                bestGameServer = gameServer;
                                bestGameDetails = gameDetails;
                            }
                        }
                    }
                }
            }
        }


        return bestGameServer;
    }

    public static ServerInfo getServerInfo(Recipient recipient) {
        return getServerInfo(recipient.getName());
    }

    public static boolean serverIsAvailable(GameType gameType, List<PlayerGroup> playerGroups) {
        List<SmartPlayer> players = new ArrayList<>();
        for (PlayerGroup playerGroup : playerGroups) {
            players.addAll(playerGroup.getPlayers());
        }

        return getBestServer(gameType, players) != null;
    }

    public static long parseDuration(String s) {
        String[] parts = s.toLowerCase().split("(?<=\\D)(?=\\d)|(?<=\\d)(?=\\D)");
        long totalValue = 0;
        for (int i = 0; i < parts.length; i += 2) {
            long value = Long.parseLong(parts[i]);
            long multiply;
            switch (parts[i + 1].toLowerCase()) {
                case "s":
                    multiply = 1000L;
                    break;
                case "m":
                    multiply = 60 * 1000L;
                    break;
                case "h":
                    multiply = 60 * 60 * 1000L;
                    break;
                case "d":
                    multiply = 24 * 60 * 60 * 1000L;
                    break;
                case "w":
                    multiply = 7 * 24 * 60 * 60 * 1000L;
                    break;
                case "mo":
                    multiply = 30 * 24 * 60 * 60 * 1000L;
                    break;
                case "y":
                    multiply = 365 * 24 * 60 * 60 * 1000L;
                    break;
                default:
                    throw new IllegalArgumentException();
            }

            totalValue += multiply * value;
        }

        return totalValue;
    }

    public static void broadcastStaffMessage(SmartPlayer smartPlayer, String message) {
        sendAllStaffMessage(smartPlayer.getComponentFormattedName(), message);
        smartPlayer.onSendMessage(message, ChatType.STAFF);
    }

    public static void sendAllStaffMessage(BaseComponent name, String message) {
        ComponentBuilder formattedMessage = new ComponentBuilder(ComponentBuilder.RED_ORANGE).append("Staff > ").append(name).color(ComponentBuilder.WHITE).append(": ").append(message);
        for (SmartPlayer onServer : SmartPlayer.getOnlineSmartPlayers()) {
            if (onServer.isStaff()) {
                onServer.sendMessage(formattedMessage);
            }
        }
    }

    public static void sendAllStaffMessage(BaseComponent baseComponent) {
        for (SmartPlayer onlineSmartPlayer : SmartPlayer.getOnlineSmartPlayers()) {
            if (onlineSmartPlayer.isStaff()) {
                onlineSmartPlayer.sendMessage(baseComponent);
            }
        }
    }

    public static Version parseVersion(String name) {
        StringBuilder value = new StringBuilder();
        for (char c : name.toCharArray()) {
            if (Character.isDigit(c) || c == '.') {
                value.append(c);
            }
        }

        return new Version(value.toString());
    }

    public static void dispatchCommand(String format, Object... data) {
        ProxyServer proxyServer = ProxyServer.getInstance();
        String result = RelayUtils.format(format, data);
        Main.info("Executing command: %s", result);
        proxyServer.getPluginManager().dispatchCommand(proxyServer.getConsole(), result);
    }

    public static void createNewServerInfo(String serverName, String ip) {
        ProxyServer proxyServer = ProxyServer.getInstance();
        int port = 25565;
        if (ip.contains(":")) {
            String[] data = ip.split(":");
            ip = data[0];
            try {
                port = Integer.parseInt(data[1]);
            } catch (Exception ignored) {
                Main.info("Error occurred while parsing int for port (%s): %s", ip, serverName);
            }
        }

        ServerInfo serverInfo = proxyServer.constructServerInfo(serverName, new InetSocketAddress(ip, port), "", false);
        proxyServer.getServers().put(serverName, serverInfo);
        Main.addToConfig(serverInfo);
        Main.info("Created ServerInfo: %s (%s:%d)", serverName, ip, port);
    }

    public static void broadcast(String format, Object... data) {
        broadcast(new TextComponent(RelayUtils.format(Text.raw(format), data)));
    }

    public static void broadcast(BaseComponent baseComponent) {
        ProxyServer.getInstance().broadcast(baseComponent);
        BotUtils.sendMessage("status", ChatColor.stripColor(baseComponent.toPlainText()));
    }

    public static void broadcast(ComponentBuilder componentBuilder) {
        broadcast(componentBuilder.getResult());
    }

    public static String socketAddressToString(SocketAddress socketAddress) {
        String addressString;

        if (socketAddress instanceof DomainSocketAddress) {
            addressString = "unix:" + ((DomainSocketAddress) socketAddress).path();
        } else if (socketAddress instanceof InetSocketAddress) {
            InetSocketAddress inetAddress = (InetSocketAddress) socketAddress;

            addressString = inetAddress.getHostString() + ":" + inetAddress.getPort();
        } else {
            addressString = socketAddress.toString();
        }

        return addressString;
    }

    public static String parseAddress(SocketAddress socketAddress) {
        InetSocketAddress serverAddress = (InetSocketAddress) socketAddress;
        return serverAddress.getHostString();
    }

    public static boolean suitableQueueSize(GameType gameType, List<QueueData> queueDatum, int size) {
        if (gameType == null) {
            return false;
        }

        QueueData queueData = queueDatum.get(0);
        for (QueueData data : queueDatum) {
            if (data.isParty()) {
                queueData = data;
                break;
            }
        }


        if (gameType.isExplicitParty() && size > 1) {
            return true;
        }

        if (queueData.isParty()) {
            return size >= 2 || size <= gameType.getTotalPlayerCount();
        }

        boolean hasSize = false;
        boolean hasWith = false;
        boolean hasOwner = false;

        for (QueueData data : queueDatum) {
            if (data.hasData("size")) {
                if (size == data.getInt("size")) {
                    Main.log("size comparison: %d v sd", size, data.getData("size"));
                    return true;
                }
                hasSize = true;
            }
            if (data.hasData("with")) {
                hasWith = true;
            }
            if (data.hasData("owner")) {
                hasOwner = true;
            }
        }

        if (hasSize || (hasWith && !hasOwner)) {
            return false;
        }

        if (gameType.isWaitForFullQueue()) {
            return size == gameType.getTotalPlayerCount();
        } else {
            return size > 1/* && size >= gameType.getTotalPlayerCount() / 2*/;
        }
    }
}