package net.t2code.alias.Spigot.cmdManagement;

import net.t2code.alias.Spigot.config.config.SelectConfig;
import net.t2code.alias.Spigot.config.languages.SelectMessages;
import net.t2code.alias.Spigot.objects.AliasObject;
import net.t2code.alias.Spigot.objects.AliasStorageObject;
import net.t2code.alias.Spigot.objects.SubAliasObject;
import net.t2code.alias.Spigot.system.BCommandSenderReciver;
import net.t2code.alias.Util;
import net.t2code.t2codelib.SPIGOT.api.commands.T2Ccmd;
import net.t2code.t2codelib.SPIGOT.api.eco.T2Ceco;
import net.t2code.t2codelib.SPIGOT.api.messages.T2Creplace;
import net.t2code.t2codelib.SPIGOT.api.messages.T2Csend;
import net.t2code.t2codelib.SPIGOT.api.plugins.T2CpluginCheck;
import net.t2code.t2codelib.SPIGOT.api.yaml.T2CLibConfig;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;
import java.util.stream.Collectors;

public class ExecuteAlias {

    public static HashMap<UUID, AliasStorageObject> aliasStorage = new HashMap<>();

    private static final String prefix = Util.getPrefix();

    protected static void storage(CommandSender sender, boolean confirm) {
        Player player = (Player) sender;

        if (!aliasStorage.containsKey(player.getUniqueId())) {
            T2Csend.player(player, SelectMessages.buyConfirmNotPossible);
            return;
        }

        AliasStorageObject object = aliasStorage.get(player.getUniqueId());
        aliasStorage.remove(player.getUniqueId());

        if (!confirm) {
            T2Csend.player(player, SelectMessages.buyCancel);
            return;
        }

        if (object.sub) {
            executeSubAlias(player, (SubAliasObject) object.aliasObject, object.alias, object.args);
        } else executeAlias(player, (AliasObject) object.aliasObject, object.alias, object.args);
    }

    protected static void aliasPlayer(CommandSender sender, AliasObject aliasObject, String alias, String[] args) {
        Player player = (Player) sender;

        if (aliasObject.adminEnable) {
            if (player.hasPermission(aliasObject.adminPermission)) {
                if (aliasObject.adminCommandEnable) {
                    aliasAdminCommand(aliasObject, alias, player, args);
                }
                if (aliasObject.adminMessageEnable) {
                    aliasAdminMessage(aliasObject, alias, player, args);
                }
                return;
            }
        }

        if (aliasObject.permNecessary) {
            if (!(player.hasPermission(aliasObject.permission.replace("<alias>", alias.toLowerCase())) || player.hasPermission("t2code.alias.admin"))) {
                String npmsg;
                if (aliasObject.permissionMSG == null || aliasObject.permissionMSG.equals("")) {
                    npmsg = SelectMessages.noPermissionForCommand;
                } else npmsg = aliasObject.permissionMSG;
                T2Csend.player(player, npmsg.replace("[cmd]", "/" + alias.toLowerCase())
                        .replace("[perm]", aliasObject.permission.replace("<alias>", alias.toLowerCase())).replace("[alias]", alias));
                return;
            }
        }
        if (aliasObject.costEnable && aliasObject.costConfirm) {
            if (!(aliasObject.costAllowBypass && player.hasPermission("t2code.alias.buy.bypass"))) {
                T2Csend.player(player, SelectMessages.buyConfirm.replace("[price]", aliasObject.costPrice.toString() + " " + SelectConfig.getBuyCurrency()));
                aliasStorage.put(player.getUniqueId(), new AliasStorageObject(aliasObject, alias, args, false));
                return;
            }
        }

        executeAlias(player, aliasObject, alias, args);
    }

    protected static void executeAlias(Player player, AliasObject aliasObject, String alias, String[] args) {
        if (aliasObject.costEnable) {
            if (!(aliasObject.costAllowBypass && player.hasPermission("t2code.alias.buy.bypass"))) {
                if (!T2Ceco.moneyRemove(prefix, player, aliasObject.costPrice)) {
                    T2Csend.player(player, SelectMessages.noMoney);
                    return;
                }
                if (SelectConfig.getBuyMessage())
                    T2Csend.player(player, SelectMessages.buy.replace("[price]", aliasObject.costPrice.toString() + " " + SelectConfig.getBuyCurrency()));
            }
        }
        if (aliasObject.commandEnable) {
            aliasCommand(aliasObject, alias, player, args);
        }
        if (aliasObject.messageEnable) {
            aliasMessage(aliasObject, alias, player, args);
        }
    }

    protected static void subAliasPlayer(CommandSender sender, SubAliasObject aliasObject, String alias, String[] args) {
        if (!aliasObject.subAliasEnable) {
            T2Csend.sender(sender, SelectMessages.aliasDisabled);
            return;
        }

        if (sender instanceof Player) {
            Player player = (Player) sender;

            if (aliasObject.adminEnable) {
                if (player.hasPermission(aliasObject.adminPermission)) {
                    if (aliasObject.adminCommandEnable) {
                        subAliasAdminCommand(aliasObject, alias, player, args);
                    }
                    if (aliasObject.adminMessageEnable) {
                        subAliasAdminMessage(aliasObject, alias, player, args);
                    }
                    return;
                }
            }

            if (aliasObject.permNecessary) {
                if (!(player.hasPermission(aliasObject.permission.replace("<alias>", alias.toLowerCase())) || player.hasPermission("t2code.alias.admin"))) {
                    String npmsg;
                    if (aliasObject.permissionMSG == null || aliasObject.permissionMSG.equals("")) {
                        npmsg = SelectMessages.noPermissionForCommand;
                    } else npmsg = aliasObject.permissionMSG;
                    T2Csend.player(player, npmsg.replace("[cmd]", "/" + alias.toLowerCase())
                            .replace("[perm]", aliasObject.permission.replace("<alias>", alias.toLowerCase())).replace("[alias]", alias));
                    return;
                }
            }
            if (aliasObject.costEnable && aliasObject.costConfirm) {
                if (!(aliasObject.costAllowBypass && player.hasPermission("t2code.alias.buy.bypass"))) {
                    T2Csend.player(player, SelectMessages.buyConfirm.replace("[price]", aliasObject.costPrice.toString() + " " + SelectConfig.getBuyCurrency()));
                    aliasStorage.put(player.getUniqueId(), new AliasStorageObject(aliasObject, alias, args, true));
                    return;
                }
            }

            executeSubAlias(player, aliasObject, alias, args);
        } else {
            if (aliasObject.consoleEnable) {
                subAliasConsole(aliasObject, alias, sender, args);
            } else T2Csend.sender(sender, SelectMessages.onlyForPlayer);
        }
    }

    protected static void executeSubAlias(Player player, SubAliasObject aliasObject, String alias, String[] args) {
        if (aliasObject.costEnable) {
            if (!(aliasObject.costAllowBypass && player.hasPermission("t2code.alias.buy.bypass"))) {
                if (!T2Ceco.moneyRemove(prefix, player, aliasObject.costPrice)) {
                    T2Csend.player(player, SelectMessages.noMoney);
                    return;
                }
                if (SelectConfig.getBuyMessage())
                    T2Csend.player(player, SelectMessages.buy.replace("[price]", aliasObject.costPrice.toString() + " " + SelectConfig.getBuyCurrency()));
            }
        }
        if (aliasObject.commandEnable) {
            subAliasCommand(aliasObject, player, args);
        }
        if (aliasObject.messageEnable) {
            subAliasMessage(aliasObject, alias, player, args);
        }
    }

    protected static void aliasConsole(AliasObject alias, CommandSender sender, String prefix) {
        if (alias.consoleCommandEnable) {
            for (String cmd : alias.consoleCommands) {
                if (alias.consoleBungeeCommand) {
                    if (T2CLibConfig.getBungee()) {
                        BCommandSenderReciver.sendToBungee(sender, cmd, true);
                    } else {
                        T2Csend.console(Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                        T2Csend.sender(sender, Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                    }
                } else {
                    T2Ccmd.console(cmd);
                }
            }
        }
        if (alias.consoleMessageEnable) {
            for (String msg : alias.consoleMessages) {
                T2Csend.console(T2Creplace.replace(prefix, msg));
            }
        }
    }

    private static void subAliasConsole(SubAliasObject aliasObject, String alias, CommandSender sender, String[] args) {
        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }
        if (aliasObject.consoleCommandEnable) {
            for (String cmd : aliasObject.consoleCommands) {
                String replace = cmd.replace("[target]", targetSt).replace("[alias]", alias);
                if (aliasObject.consoleBungeeCommand) {
                    if (T2CLibConfig.getBungee()) {
                        BCommandSenderReciver.sendToBungee(sender, replace, true);
                    } else {
                        T2Csend.console(Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                        T2Csend.sender(sender, Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                    }
                } else {
                    T2Ccmd.console(replace);
                }
            }
        }
        if (aliasObject.consoleMessageEnable) {
            for (String msg : aliasObject.consoleMessages) {
                T2Csend.console(T2Creplace.replace(prefix, msg));
            }
        }
    }

    private static void aliasAdminCommand(AliasObject aliasObject, String alias, Player player, String[] args) {
        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }
        for (String cmd : aliasObject.adminCommands) {
            if (aliasObject.adminBungeeCommand) {
                if (T2CLibConfig.getBungee()) {
                    BCommandSenderReciver.sendToBungee(player, cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias), aliasObject.adminCommandAsConsole);

                } else {
                    T2Csend.console(Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                    T2Csend.player(player, Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                }
            } else {
                if (aliasObject.adminCommandAsConsole) {
                    T2Ccmd.console(cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias));
                } else {
                    T2Ccmd.player(player, cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias));
                }
            }
        }
    }

    private static void subAliasAdminCommand(SubAliasObject aliasObject, String alias, Player player, String[] args) {
        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }
        for (String cmd : aliasObject.adminCommands) {
            if (aliasObject.adminBungeeCommand) {
                if (T2CLibConfig.getBungee()) {
                    BCommandSenderReciver.sendToBungee(player, cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias), aliasObject.adminCommandAsConsole);

                } else {
                    T2Csend.console(Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                    T2Csend.player(player, Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                }
            } else {
                if (aliasObject.adminCommandAsConsole) {
                    T2Ccmd.console(cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias));
                } else {
                    T2Ccmd.player(player, cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias));
                }
            }
        }
    }

    private static void aliasAdminMessage(AliasObject aliasObject, String alias, Player player, String[] args) {
        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }
        for (String msg : aliasObject.adminMessages) {
            String text;
            if (T2CpluginCheck.papi()) {
                text = T2Creplace.replace(prefix, player, replacePlayer(msg, player)).replace("[target]", targetSt).replace("[alias]", alias);
            } else {
                text = T2Creplace.replace(prefix, replacePlayer(msg, player)).replace("[target]", targetSt).replace("[alias]", alias);
            }
            T2Csend.player(player, text);
        }
    }

    private static void subAliasAdminMessage(SubAliasObject subAliasObject, String alias, Player player, String[] args) {
        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }
        for (String msg : subAliasObject.adminMessages) {
            String text;
            if (T2CpluginCheck.papi()) {
                text = T2Creplace.replace(prefix, player, replacePlayer(msg, player)).replace("[target]", targetSt).replace("[alias]", alias);
            } else {
                text = T2Creplace.replace(prefix, replacePlayer(msg, player)).replace("[target]", targetSt).replace("[alias]", alias);
            }
            T2Csend.player(player, text);
        }
    }

    private static void aliasCommand(AliasObject aliasObject, String alias, Player player, String[] args) {
        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }
        for (String cmd : aliasObject.command) {
            if (aliasObject.bungeeCommand) {
                if (T2CLibConfig.getBungee()) {
                    BCommandSenderReciver.sendToBungee(player, cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias), aliasObject.commandAsConsole);
                } else {
                    T2Csend.console(Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                    T2Csend.player(player, Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                }
            } else {
                if (aliasObject.commandAsConsole) {
                    T2Ccmd.console(cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias));
                } else {
                    T2Ccmd.player(player, cmd.replace("[player]", player.getName()).replace("[target]", targetSt).replace("[alias]", alias));
                }
            }
        }
    }

    private static void subAliasCommand(SubAliasObject alias, Player player, String[] args) {
        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }
        for (String cmd : alias.command) {
            if (alias.bungeeCommand) {
                if (T2CLibConfig.getBungee()) {
                    BCommandSenderReciver.sendToBungee(player, cmd.replace("[player]", player.getName()).replace("[target]", targetSt), alias.commandAsConsole);

                } else {
                    T2Csend.console(Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                    T2Csend.player(player, Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                }
            } else {
                if (alias.commandAsConsole) {
                    T2Ccmd.console(cmd.replace("[player]", player.getName()).replace("[target]", targetSt));
                } else {
                    T2Ccmd.player(player, cmd.replace("[player]", player.getName()).replace("[target]", targetSt));
                }
            }
        }
    }

    private static void aliasMessage(AliasObject aliasObject, String alias, Player player, String[] args) {

        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }

        for (String msg : aliasObject.messages) {
            String text;
            if (T2CpluginCheck.papi()) {
                text = T2Creplace.replace(prefix, player, replacePlayer(msg, player)).replace("[target]", targetSt).replace("[alias]", alias);
            } else {
                text = T2Creplace.replace(prefix, replacePlayer(msg, player)).replace("[target]", targetSt).replace("[alias]", alias);
            }
            T2Csend.player(player, text);
        }
    }

    private static void subAliasMessage(SubAliasObject subAliasObject, String alias, Player player, String[] args) {
        String targetSt = "[target]";
        try {
            List<String> results = Arrays.stream(args).filter(a -> a.contains("-p:")).collect(Collectors.toList());
            targetSt = results.get(0).replace("-p:", "");
        } catch (Exception ignored) {

        }
        for (String msg : subAliasObject.messages) {
            String text;
            if (T2CpluginCheck.papi()) {
                text = T2Creplace.replace(prefix, player, replacePlayer(msg, player)).replace("[target]", targetSt).replace("[alias]", alias);
            } else {
                text = T2Creplace.replace(prefix, replacePlayer(msg, player)).replace("[target]", targetSt).replace("[alias]", alias);
            }
            T2Csend.player(player, text);
        }
    }

    private static String replacePlayer(String s, Player player) {
        return s.replace("[player]", player.getName());
    }
}