package com.lifeknight.relaymcbungeemain.commands.amenities;

import com.lifeknight.relaymcbungeemain.commands.CommandUtilities;
import com.lifeknight.relaymcbungeemain.player.SmartPlayer;
import com.lifeknight.relaymcbungeemain.utilities.PlayerUtilities;
import com.lifeknight.relayutils.RelayUtils;
import com.lifeknight.relayutils.basic.Miscellaneous;
import com.lifeknight.relayutils.basic.SwearUtils;
import com.lifeknight.relayutils.basic.Text;
import com.lifeknight.relayutils.filter.ChatFilter;
import com.lifeknight.relayutils.player.Group;
import com.lifeknight.relayutils.player.Nick;
import net.md_5.bungee.api.ChatColor;
import net.md_5.bungee.api.CommandSender;
import net.md_5.bungee.api.connection.ProxiedPlayer;
import net.md_5.bungee.api.plugin.Command;
import net.md_5.bungee.api.plugin.TabExecutor;

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

import static org.bukkit.ChatColor.RED;
import static org.bukkit.ChatColor.YELLOW;

public class NicknameCommand extends Command implements TabExecutor {
    public NicknameCommand() {
        super("nickname", null, "nick");
    }

    public static final List<String> COMMANDS = Arrays.asList(
            "enable",
            "disable",
            "set",
            "info",
            "view"
    );

    @Override
    public void execute(CommandSender sender, String[] arguments) {
        if (!(sender instanceof ProxiedPlayer)) return;

        SmartPlayer smartPlayer = SmartPlayer.getSmartPlayer((ProxiedPlayer) sender);

        if (!smartPlayer.isInGroupOrHigher(Group.TIERIII)) {
            smartPlayer.sendChampionPurchaseMessage();
        } else {
            if (arguments.length > 0) {
                switch (COMMANDS.indexOf(arguments[0].toLowerCase())) {
                    case 0:
                        this.handleNickEnable(smartPlayer);
                        break;
                    case 1:
                        this.handleNickDisable(smartPlayer);
                        break;
                    case 2:
                        this.handleNickSet(smartPlayer, Miscellaneous.from(arguments, 1));
                        break;
                    case 3:
                        this.handleNickInfo(smartPlayer);
                        break;
                    case 4:
                        this.handleNickView(smartPlayer, arguments);
                        break;
                    default:
                        switch (arguments[0].toLowerCase()) {
                            case "on":
                                this.handleNickEnable(smartPlayer);
                                break;
                            case "reset":
                            case "off":
                                this.handleNickDisable(smartPlayer);
                                break;
                            case "random":
                                this.handleNickSet(smartPlayer, new String[]{"random"});
                                break;
                            case "custom":
                                List<String> strings = new ArrayList<>(Arrays.asList(Miscellaneous.from(arguments, 1)));
                                strings.add(0, "custom");
                                this.handleNickSet(smartPlayer, strings.toArray(new String[0]));
                                break;
                            default:
                                smartPlayer.sendCommandsMessage(COMMANDS);
                                break;
                        }
                }
            } else {
                smartPlayer.sendCommandsMessage(COMMANDS);
            }
        }
    }

    public void handleNickEnable(SmartPlayer smartPlayer) {
        if (smartPlayer.isNicked()) {
            smartPlayer.sendErrorMessage("You are already nicked!");
        } else {
            if (smartPlayer.hasNick()) {
                smartPlayer.setNicked(true);
                smartPlayer.sendSuccessMessage("Your nick has been enabled.");
                smartPlayer.onNickChange();
            } else {
                smartPlayer.sendErrorMessage("You must set your nick first!");
            }
        }
    }

    public void handleNickDisable(SmartPlayer smartPlayer) {
        if (smartPlayer.isNicked()) {
            smartPlayer.setNicked(false);
            smartPlayer.sendSuccessMessage("You are no longer nicked.");
            smartPlayer.onNickChange();
        } else {
            smartPlayer.sendErrorMessage("You are not nicked!");
        }
    }

    public void handleNickSet(SmartPlayer smartPlayer, String[] arguments) {
        if (arguments.length == 0) {
            smartPlayer.sendUsageMessage("/nickname set random/custom");
        } else {
            switch (arguments[0].toLowerCase()) {
                case "random":
                    if (smartPlayer.canNick()) {
                        this.randomlyAssignNick(smartPlayer);
                    }
                    break;
                case "custom":
                    if (!smartPlayer.isInGroupOrHigher(Group.CHAMPION)) {
                        smartPlayer.sendChampionPurchaseMessage();
                    } else if (smartPlayer.getChampionTier() == 1) {
                        smartPlayer.sendErrorMessage("You must have purchase Premium rank twice to use the custom nick feature!");
                        smartPlayer.sendChampionPurchaseMessage();
                    } else if (smartPlayer.canNick()) {
                        this.assignCustomNick(smartPlayer, Miscellaneous.from(arguments, 1));
                    }
                    break;
                default:
                    smartPlayer.sendUsageMessage("/nickname set random/custom");
                    break;
            }
        }
    }

    public void assignCustomNick(SmartPlayer smartPlayer, String[] arguments) {
        if (arguments.length == 0) {
            smartPlayer.sendUsageMessage("/nickname set custom [name] <skin>");
            return;
        }

        String name = arguments[0];

        SmartPlayer whoHas = SmartPlayer.getSmartPlayerOrNick(name);
        if ((RelayUtils.getUUID(name) != null || whoHas != null) && !(smartPlayer.equals(whoHas) || smartPlayer.isAdministrator())) {
            smartPlayer.sendErrorMessage("A player already has the name %s%s%s!", YELLOW, name, RED);
            return;
        }

        if (!Text.removeAllPunctuation(name).equals(name) || name.length() < 3 || name.length() > 16) {
            smartPlayer.sendErrorMessage("Your nick must only contain letters A-Z, numbers 0-9, at least 3 characters and at most 16 characters in length!");
            return;
        }

        if (!SwearUtils.canSendMessageAtLevel(name, ChatFilter.HIGH)) {
            smartPlayer.sendErrorMessage("This username has been deemed inappropriate.");
            return;
        }

        Group group = null;
        String skinOwner = null;
        String[] textures = null;

        if (arguments.length > 1) {
            skinOwner = arguments[1];
            if (skinOwner.equalsIgnoreCase("self")) {
                skinOwner = smartPlayer.getName();
            }

            UUID uuid = RelayUtils.getUUID(skinOwner);

            if (uuid == null) {
                smartPlayer.noPlayerFound(skinOwner);
                return;
            }

            textures = RelayUtils.getTextureFromUUID(uuid);

            if (textures == null) {
                smartPlayer.sendErrorMessage("An error occurred while attempting to get the skin for that user.");
                return;
            }

        }

        if (arguments.length > 2) {
            if (!smartPlayer.isAdministrator()) {
                group = Group.DEFAULT;
            } else {
                group = Group.getGroup(arguments[2]);

                if (group == null) {
                    switch (arguments[1].toLowerCase()) {
                        case "tier1":
                            group = Group.TIERI;
                            break;
                        case "tier2":
                            group = Group.TIERII;
                            break;
                        case "tier3":
                            group = Group.TIERIII;
                            break;
                    }

                    if (group == null) {
                        smartPlayer.sendUsageMessage("/nickname custom [name] <skin> <rank>");
                        return;
                    }
                }
            }
        }

        if (group == null) {
            group = Group.DEFAULT;
        }

        if (skinOwner == null) {
            skinOwner = smartPlayer.getName();
            textures = RelayUtils.getTextureFromUUID(smartPlayer.getUUID());
        }

        smartPlayer.setNick(new Nick(name, skinOwner, textures, group));
    }

    public void handleNickInfo(SmartPlayer smartPlayer) {
        if (smartPlayer.hasNick()) {
            smartPlayer.sendSuccessMessage("Your nick:");
            smartPlayer.sendInfoMessage("Name: %s", smartPlayer.getNick().getFormattedName());
            if (smartPlayer.getNick().textures != null) {
                smartPlayer.sendInfoMessage("Skin: %s%s", ChatColor.GREEN, smartPlayer.getNick().texturesOwnerName);
            }
        } else {
            smartPlayer.sendErrorMessage("You do not have a nick!");
        }
    }

    public void randomlyAssignNick(SmartPlayer smartPlayer) {
        smartPlayer.setNick(PlayerUtilities.generateRandomNick());
    }

    public void handleNickView(SmartPlayer smartPlayer, String[] arguments) {
        if (!smartPlayer.isStaff()) {
            CommandUtilities.sendInsufficientPermissionsMessage(smartPlayer.getProxiedPlayer());
            return;
        }

        if (arguments.length > 1) {
            String name = arguments[1];
            SmartPlayer nicked = SmartPlayer.getSmartPlayerOrNick(name);

            if (nicked == null) {
                smartPlayer.sendErrorMessage("No player/nicked player found with the name of %s%s%s.", ChatColor.YELLOW, name, ChatColor.RED);
            } else {
                if (nicked.getNick() != null) {
                    smartPlayer.sendInfoMessage("%s%s nickname: %s", nicked.getPossessiveFormattedName(), ChatColor.YELLOW, nicked.getFormattedNickname());
                } else {
                    smartPlayer.sendErrorMessage("%s%s is not nicked.", nicked.getFormattedName(), ChatColor.RED);
                }
            }
        } else {
            smartPlayer.sendUsageMessage("/nickname view [player]");
        }
    }

    @Override
    public Iterable<String> onTabComplete(CommandSender sender, String[] arguments) {
        if (arguments.length == 1) {
            return Text.returnStartingEntries(COMMANDS, arguments[0], true);
        }

        return new ArrayList<>();
    }
}