package net.t2code.alias.Spigot.cmdManagement;

import net.t2code.alias.Spigot.Main;
import net.t2code.alias.Spigot.config.config.SelectConfig;
import net.t2code.alias.Spigot.config.languages.SelectMessages;
import net.t2code.alias.Spigot.objects.AliasObjekt;
import net.t2code.alias.Spigot.objects.SubAliasObjekt;
import net.t2code.alias.Spigot.system.*;
import net.t2code.alias.Util;
import net.t2code.lib.Spigot.Lib.commands.Cmd;
import net.t2code.lib.Spigot.Lib.commands.Tab;
import net.t2code.lib.Spigot.Lib.eco.Eco;
import net.t2code.lib.Spigot.Lib.messages.send;
import net.t2code.lib.Spigot.Lib.plugins.PluginCheck;
import net.t2code.lib.Spigot.Lib.replace.Replace;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.command.TabCompleter;
import org.bukkit.entity.Player;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

public class RegisterCommands extends Command implements TabCompleter {
    private String alias;
    private String prefix = Util.getPrefix();

    public RegisterCommands(String alias) {
        super(alias);
        this.alias = alias;
    }

    @Override
    public boolean execute(CommandSender sender, String commandLabel, String[] args) {
        AliasObjekt alias = Main.aliasHashMap.get(this.alias);

        if (!alias.aliasEnable) {
            send.sender(sender, SelectMessages.aliasDisabled);
            return true;
        }
        if (args.length == 0) {
            if (sender instanceof Player) {
                exPlayer(sender, alias);
            } else {
                if (alias.consoleEnable) {
                    console(alias, sender, prefix);
                } else send.sender(sender, SelectMessages.onlyForPlayer);
            }
        } else {
            for (String sals : Main.allSubAliases) {
                SubAliasObjekt sal = Main.subAliasHashMap.get(sals);
                if (args.length == sal.subAliasArg) {
                    for (String al : sal.subAliasList) {
                        if (args[sal.subAliasArg].toLowerCase().equals(al)) {
                            RegisterSubAliasCommands.execute(sender, sal, al);
                        }
                    }
                }
            }
        }
        return true;
    }

    private void exPlayer(CommandSender sender, AliasObjekt alias) {
        Player player = (Player) sender;

        if (alias.adminEnable) {
            if (player.hasPermission(alias.adminPermission)) {
                if (alias.adminCommandEnable) {
                    adminCommand(alias, player);
                }
                if (alias.adminMessageEnable) {
                    adminMessage(alias, player, prefix);
                }
                return;
            }
        }

        if (alias.permNecessary) {
            if (!(player.hasPermission("t2code.alias.use." + this.alias.toLowerCase()) || player.hasPermission("t2code.alias.admin"))) {
                send.player(player, SelectMessages.noPermissionForCommand.replace("[cmd]", "/" + this.alias.toLowerCase())
                        .replace("[perm]", "t2code.alias.use." + this.alias.toLowerCase()));
                return;
            }
        }
        if (alias.costEnable) {
            if (!(alias.costAllowBypass && player.hasPermission("t2code.alias.buy.bypass"))) {
                if (!Eco.moneyRemove(prefix, player, alias.costPrice)) {
                    send.player(player, SelectMessages.noMoney);
                    return;
                }
                if (SelectConfig.buyMessage) send.player(player, SelectMessages.buy.replace("[price]", alias.costPrice.toString()));
            }
        }
        if (alias.commandEnable) {
            command(alias, player);
        }
        if (alias.messageEnable) {
            message(alias, player, prefix);
        }
    }

    private static void adminCommand(AliasObjekt alias, Player player) {
        for (String cmd : alias.adminCommands) {
            if (alias.adminBungeeCommand) {
                if (SelectConfig.Bungee) {
                    if (alias.adminCommandAsConsole) {
                        BCommandSenderReciver.sendToBungee(player, cmd.replace("[player]", player.getName()), true);
                    } else BCommandSenderReciver.sendToBungee(player, cmd.replace("[player]", player.getName()), false);

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

    private static void adminMessage(AliasObjekt alias, Player player, String prefix) {
        for (String msg : alias.adminMessages) {
            String text;
            String hover;
            if (PluginCheck.papi()) {
                text = Replace.replace(prefix, player, replacePlayer(msg, player));
            } else {
                text = Replace.replace(prefix, replacePlayer(msg, player));
            }
            send.player(player, text);
        }
    }

    private static void command(AliasObjekt alias, Player player) {
        for (String cmd : alias.command) {
            if (alias.bungeeCommand) {
                if (SelectConfig.Bungee) {
                    if (alias.commandAsConsole) {
                        BCommandSenderReciver.sendToBungee(player, cmd.replace("[player]", player.getName()), true);
                    } else BCommandSenderReciver.sendToBungee(player, cmd.replace("[player]", player.getName()), false);

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

    private static void message(AliasObjekt alias, Player player, String prefix) {
        for (String msg : alias.messages) {
            String text;
            String hover;
            if (PluginCheck.papi()) {
                text = Replace.replace(prefix, player, replacePlayer(msg, player));
            } else {
                text = Replace.replace(prefix, replacePlayer(msg, player));
            }
            send.player(player, text);
        }
    }

    private static void console(AliasObjekt alias, CommandSender sender, String prefix) {
        if (alias.consoleCommandEnable) {
            for (String cmd : alias.consoleCommands) {
                if (alias.consoleBungeeCommand) {
                    if (SelectConfig.Bungee) {
                        BCommandSenderReciver.sendToBungee(sender, cmd, true);
                    } else {
                        send.console(Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                        send.sender(sender, Util.getPrefix() + " §4To use bungee commands, enable the Bungee option in the config.");
                    }
                } else {
                    Cmd.console(cmd);
                }
            }
        }
        if (alias.consoleMessageEnable) {
            for (String msg : alias.consoleMessages) {
                send.console(Replace.replace(prefix, msg));
            }
        }
    }

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

    private static HashMap<String, String> arg1 = new HashMap<String, String>();

    @Override
    public List<String> onTabComplete(CommandSender sender, Command cmd, String s, String[] args) {
        List<String> list = new ArrayList<>();
        arg1.clear();
        for (String sals : Main.allSubAliases) {
            SubAliasObjekt sal = Main.subAliasHashMap.get(sals);
            for (String al : sal.subAliasList) {
                arg1.put(al, "t2code.alias.use.subalias." + al.toLowerCase());
            }
            Tab.tab(list, sender, sal.subAliasArg, args, arg1);
        }
        return list;
    }
}