package me.monster.ranks.command.permSubcommands;

import me.monster.colors.ColorUtils;
import me.monster.commands.SubCommand;
import me.monster.ranks.database.DbManager;
import me.monster.ranks.database.models.Groups;
import me.monster.ranks.utils.PlayerUpdater;
import org.bukkit.Bukkit;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

import java.sql.SQLException;
import java.util.List;

public class UserSub extends SubCommand {
    @Override
    public String getName() {
        return "user";
    }

    @Override
    public List<String> getAliases() {
        return List.of("user", "player");
    }

    @Override
    public String getDescription() {
        return "Manage Player Groups";
    }

    @Override
    public String getSyntax() {
        return "&c/perm user <user>";
    }

    @Override
    public void perform(CommandSender sender, String[] args) {
        if (sender.hasPermission("ranks.manage.user")) {
            if (args.length == 1) {
                sender.sendMessage(ColorUtils.translateColorCodes(getSyntax()));
            } else if (args.length == 2) {
                sender.sendMessage(ColorUtils.translateColorCodes("&c/perm user " + args[1] + " <add/remove/set/update> [group]"));
            } else {
                try {
                    manageSystem(List.of(args), sender);
                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
            }
        } else {
            sender.sendMessage(ColorUtils.translateColorCodes("&cYou do not have permission to use this command."));
        }
    }

    public void manageSystem(List<String> args, CommandSender sender) throws SQLException {
        Player target = Bukkit.getPlayer(args.get(1));
        assert target != null;
        target.sendMessage(String.valueOf(args));
        String uuid = target.getUniqueId().toString();
        if (args.size() >= 3) {
            if (args.get(2).equalsIgnoreCase("add")) {
                if (getGroupNames().contains(args.get(3))) {
                    DbManager.addPlayerGroup(new me.monster.ranks.database.models.User(uuid, args.get(3), 0, null));
                    new PlayerUpdater(target);
                } else if (!getGroupNames().contains(args.get(3))) {
                    sender.sendMessage(ColorUtils.translateColorCodes("&cGroup does not exist."));
                }
            } else if (args.get(2).equalsIgnoreCase("remove")) {
                if (getGroupNames().contains(args.get(3))) {
                    DbManager.deletePlayerGroups(new me.monster.ranks.database.models.User(uuid, args.get(3), 0, null));
                    new PlayerUpdater(target);
                } else {
                    sender.sendMessage(ColorUtils.translateColorCodes("&cGroup does not exist."));
                }
            } else if (args.get(2).equalsIgnoreCase("set")) {
                if (getGroupNames().contains(args.get(3))) {
                    DbManager.updatePlayerGroups(new me.monster.ranks.database.models.User(uuid, args.get(3), 0, null));
                    new PlayerUpdater(target);
                } else {
                    sender.sendMessage(ColorUtils.translateColorCodes("&cGroup does not exist."));
                }
            } else if (args.get(2).equalsIgnoreCase("update")) {
                new PlayerUpdater(target);
            }
        }
    }


    public List<String> getGroupNames() {
        try {
            return DbManager.getAllGroups().stream().map(Groups::getGroupName).toList();
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    @Override
    public List<String> getSubcommandArguments(Player player, String[] strings){
        if (player.hasPermission("ranks.manage.user")){
            if (strings.length == 2) {
                return List.of(Bukkit.getServer().getOnlinePlayers().stream().map(Player::getName).toArray(String[]::new));
            } else if (strings.length == 3) {
                return List.of("add", "remove", "set", "update");
            } else if (strings.length == 4) {
                try {
                    return List.of(DbManager.getAllGroups().stream().map(Groups::getGroupName).toArray(String[]::new));
                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
            } else {
                return null;
            }
        }
        return null;
    }
}