package xyz.etztech.deluxegroups.command;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.OfflinePlayer;
import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import xyz.etztech.deluxegroups.DeluxeGroup;
import xyz.etztech.deluxegroups.DeluxeGroups;
import xyz.etztech.deluxegroups.DeluxeUtil;

public class CommandGroup
        implements CommandExecutor
{
    DeluxeGroups plugin;

    public CommandGroup(DeluxeGroups paramDeluxeGroups)
    {
        this.plugin = paramDeluxeGroups;
    }

    public boolean onCommand(CommandSender sender, Command command, String base, String[] args)
    {
        if (!(sender instanceof Player))
        {
            sender.sendMessage("This command is not supported in console yet!");
            return true;
        }
        Player localPlayer1 = (Player)sender;

        if (args.length == 0) {
            if (DeluxeGroups.getDatabase().inGroup(localPlayer1.getUniqueId().toString())) {
                DeluxeGroup deluxeGroup = DeluxeGroups.getDatabase().getPlayerGroup(localPlayer1.getUniqueId().toString());
                DeluxeUtil.sms(localPlayer1, ChatColor.AQUA + "You are in group " + deluxeGroup.getName());
            } else {
                DeluxeUtil.sms(localPlayer1, ChatColor.RED + "You are not in a group!");
            }
        } else {
            String subcommand = args[0];
            if ("create".equals(subcommand.toLowerCase())) {
                createGroup(localPlayer1, args);
            } else if ("join".equals(subcommand.toLowerCase())) {
                joinGroup(localPlayer1, args);
            } else if ("leave".equals(subcommand.toLowerCase())) {
                leaveGroup(localPlayer1, false);
            } else if ("list".equals(subcommand.toLowerCase())) {
                listGroup(localPlayer1, args);
            } else if ("password".equals(subcommand.toLowerCase())) {
                modifyPassword(localPlayer1, args);
            } else if ("permanent".equals(subcommand.toLowerCase())) {
                modifyPermanent(localPlayer1, args);
            } else if ("kick".equals(subcommand.toLowerCase())) {
                kick(localPlayer1, args);
            } else {
                help(localPlayer1);
            }
        }

        return true;
    }


    private void createGroup(Player player, String[] args) {
        if (args.length < 2) {
            DeluxeUtil.sms(player, ChatColor.RED + Usage.CREATE.getFullUsage(player));
            return;
        }
        if (DeluxeGroups.getDatabase().inGroup(player.getUniqueId().toString())) {
            DeluxeUtil.sms(player, ChatColor.RED + "You are already in a group! Leave it first to create a new one.");
            return;
        }
        DeluxeGroup cg = new DeluxeGroup();
        if (!DeluxeGroups.getDatabase().groupExists(args[1])) {
            cg.setName(args[1]);
            if (args.length == 2) {
                DeluxeUtil.sms(player, ChatColor.AQUA + "Creating " + args[1] + " with no password.");
            } else if ( args.length == 3) {
                DeluxeUtil.sms(player, ChatColor.RED + "You didn't confirm your password.");
                return;
            } else if (args.length == 4) {
                String password1 = args[2];
                String password2 = args[3];
                if (password1.equals(password2)) {
                    cg.setPassword(args[2]);
                    DeluxeUtil.sms(player, ChatColor.AQUA + "Creating " + args[1] + " with password " + args[2] + ".");
                } else {
                    DeluxeUtil.sms(player, ChatColor.RED + "Your passwords did not match!");
                    return;
                }
            } else {
                DeluxeUtil.sms(player, ChatColor.RED + "Too many parameters!");
                return;
            }
            cg.add(player);
            int id = DeluxeGroups.getDatabase().addGroup(cg);
            DeluxeGroups.getDatabase().addPlayer(player.getUniqueId().toString(), id);
        } else {
            DeluxeUtil.sms(player, ChatColor.RED + "A group with that name already exists!");
        }
    }

    private void joinGroup(Player player, String[] args) {
        if (args.length < 2) {
            DeluxeUtil.sms(player, ChatColor.RED + Usage.JOIN.getFullUsage(player));
            return;
        }
        if (DeluxeGroups.getDatabase().groupExists(args[1])) {
            if (DeluxeGroups.getDatabase().inGroup(player.getUniqueId().toString())) {
                DeluxeGroup group = DeluxeGroups.getDatabase().getPlayerGroup(player.getUniqueId().toString());
                if (args[1].toLowerCase().equals(group.getName().toLowerCase())) {
                    DeluxeUtil.sms(player, ChatColor.RED + "You are already in "
                            + group.getName());
                    return;
                }
                leaveGroup(player, true);
            }
            DeluxeGroup group = DeluxeGroups.getDatabase().getGroup(args[1]);
            if (args.length == 2) {
                if (!group.hasPassword()) {
                    group.sendMessage(player.getName() + " has joined the group!");
                    DeluxeUtil.sms(player, ChatColor.AQUA + "You have joined " + group.getName() + "!");
                    DeluxeGroups.getDatabase().addPlayer(player.getUniqueId().toString(), group.getId());
                } else {
                    DeluxeUtil.sms(player, ChatColor.RED + group.getName() + " is password protected.");
                }
            } else if ( args.length == 3) {
                if (group.hasPassword() && args[2].equals(group.getPassword())) {
                    group.sendMessage(player.getName() + " has joined the group!");
                    DeluxeUtil.sms(player, ChatColor.AQUA + "You have joined " + group.getName() + "!");
                    DeluxeGroups.getDatabase().addPlayer(player.getUniqueId().toString(), group.getId());
                } else if (!group.hasPassword()) {
                    group.sendMessage(player.getName() + " has joined the group!");
                    DeluxeUtil.sms(player, ChatColor.AQUA + "You have joined " + group.getName() + "!");
                    DeluxeGroups.getDatabase().addPlayer(player.getUniqueId().toString(), group.getId());
                } else {
                    DeluxeUtil.sms(player, ChatColor.RED + "Incorrect password.");
                }
            } else {
                DeluxeUtil.sms(player, ChatColor.RED + "Too many parameters!");
            }
        } else {
            DeluxeUtil.sms(player, ChatColor.RED + "A group with that name does not exist!");
        }
    }

    private void listGroup(Player player, String[] args) {
        if (args.length == 1) {
            if (DeluxeGroups.getDatabase().inGroup(player.getUniqueId().toString())) {
                DeluxeGroup deluxeGroup = DeluxeGroups.getDatabase().getPlayerGroup(player.getUniqueId().toString());
                StringBuilder message = new StringBuilder(ChatColor.DARK_AQUA + "===== " + deluxeGroup.getName() + " =====");
                for (OfflinePlayer groupPlayer : deluxeGroup.getGroupList()) {
                    if (groupPlayer.isOnline()) {
                        message.append("\n" + ChatColor.AQUA + groupPlayer.getName() + " (" + ChatColor.GREEN + "online" + ChatColor.AQUA + ")");
                    } else {
                        message.append("\n" + ChatColor.AQUA + groupPlayer.getName() + " (" + ChatColor.RED + "offline" + ChatColor.AQUA + ")");
                    }
                }
                DeluxeUtil.sms(player, message.toString());
            } else {
                DeluxeUtil.sms(player, ChatColor.RED + "You are not in a group!");
            }
        } else if (args.length == 2) {
            if (player.hasPermission("deluxegroups.admin")) {
                DeluxeGroup carrotGroup = DeluxeGroups.getDatabase().getGroup(args[1]);
                if (carrotGroup != null) {
                    StringBuilder message = new StringBuilder(ChatColor.DARK_AQUA + "===== " + carrotGroup.getName() + " =====");
                    for (OfflinePlayer groupPlayer : carrotGroup.getGroupList()) {
                        if (groupPlayer.isOnline()) {
                            message.append("\n" + ChatColor.AQUA + groupPlayer.getName() + " (" + ChatColor.GREEN + "online" + ChatColor.AQUA + ")");
                        } else {
                            message.append("\n" + ChatColor.AQUA + groupPlayer.getName() + " (" + ChatColor.RED + "offline" + ChatColor.AQUA + ")");
                        }
                    }
                    DeluxeUtil.sms(player, message.toString());
                } else {
                    DeluxeUtil.sms(player, ChatColor.RED + "There is no group with that name!");
                }
            } else {
                DeluxeUtil.sms(player, ChatColor.RED + "You do not have permission to use this command!");
            }
        } else {
            DeluxeUtil.sms(player, ChatColor.RED + Usage.LIST.getFullUsage(player));
        }
    }

    private void leaveGroup(Player player, boolean fromJoin) {
        if (DeluxeGroups.getDatabase().inGroup(player.getUniqueId().toString())) {
            DeluxeGroup leaveGroup = DeluxeGroups.getDatabase().getPlayerGroup(player.getUniqueId().toString());
            DeluxeGroups.getDatabase().removePlayer(player.getUniqueId().toString());
            DeluxeUtil.sms(player, ChatColor.AQUA + "You have left " + leaveGroup.getName());
            leaveGroup.remove(player);
            leaveGroup.sendMessage(ChatColor.AQUA + player.getName() + " has left the group.");
            if (leaveGroup.getSize() < 1 && !leaveGroup.getPermanent()) {
                // Disband
                DeluxeGroups.getDatabase().removeGroup(leaveGroup.getId());
            }
        } else if (!fromJoin){
            DeluxeUtil.sms(player, ChatColor.RED + "You are not in a group!");
        }
    }

    private void modifyPassword(Player player, String[] args) {
        if (!player.hasPermission("deluxegroups.admin")) {
            DeluxeUtil.sms(player, ChatColor.RED + "You do not have permission to use this command!");
            return;
        }
        if (args.length < 4) {
            DeluxeUtil.sms(player, ChatColor.RED + Usage.PASSWORD.getFullUsage(player));
            return;
        }
        DeluxeGroup group = DeluxeGroups.getDatabase().getGroup(args[1]);
        if (group != null) {
            if (args[2].equals(args[3])) {
                group.setPassword(args[2]);
                DeluxeGroups.getDatabase().updateGroup(group);
                DeluxeUtil.sms(player, ChatColor.GREEN + "Password for " + group.getName() + " changed to '" + group.getPassword() + "'.");
            } else {
                DeluxeUtil.sms(player, ChatColor.RED + "Passwords did not match.");
            }
        } else {
            DeluxeUtil.sms(player, ChatColor.RED + "Group '" + args[1] + "' does not exist.");
        }
    }

    private void modifyPermanent(Player player, String[] args) {
        if (!player.hasPermission("deluxegroups.admin")) {
            DeluxeUtil.sms(player, ChatColor.RED + "You do not have permission to use this command!");
            return;
        }
        if (args.length < 3) {
            DeluxeUtil.sms(player, ChatColor.RED + Usage.PERMANENT.getFullUsage(player));
            return;
        }
        DeluxeGroup group = DeluxeGroups.getDatabase().getGroup(args[1]);
        if (group != null) {
            Boolean perm = DeluxeUtil.resolveBoolean(args[2]);
            if (perm != null) {
                group.setPermanent(perm);
                DeluxeGroups.getDatabase().updateGroup(group);
                DeluxeUtil.sms(player, ChatColor.GREEN + group.getName() + " is " + (group.getPermanent() ? "now" : "no longer") + " permanent.");
                if (!group.getPermanent() && group.getSize() < 1) {
                    // Disband
                    DeluxeGroups.getDatabase().removeGroup(group.getId());
                }
            } else {
                DeluxeUtil.sms(player, ChatColor.RED + Usage.PERMANENT.getFullUsage(player));
            }
        } else {
            DeluxeUtil.sms(player, ChatColor.RED + "Group '" + args[1] + "' does not exist.");
        }
    }

    private void kick(Player player, String[] args) {
        if (!player.hasPermission("deluxegroups.admin")) {
            DeluxeUtil.sms(player, ChatColor.RED + "You do not have permission to use this command!");
            return;
        }
        if (args.length < 2) {
            DeluxeUtil.sms(player, ChatColor.RED + Usage.KICK.getFullUsage(player));
            return;
        }
        Player argPlayer = Bukkit.getPlayer(args[1]);
        if (argPlayer != null) {
            if (DeluxeGroups.getDatabase().inGroup(argPlayer.getUniqueId().toString())) {
                DeluxeGroup group = DeluxeGroups.getDatabase().getPlayerGroup(argPlayer.getUniqueId().toString());
                DeluxeGroups.getDatabase().removePlayer(argPlayer.getUniqueId().toString());
                DeluxeUtil.sms(player, ChatColor.GREEN + argPlayer.getName() + " was kicked from " + group.getName() + ".");
                DeluxeUtil.sms(argPlayer, ChatColor.RED + "You were kicked from " + group.getName() + ".");
                if (!group.getPermanent() && group.getSize() < 1) {
                    // Disband
                    DeluxeGroups.getDatabase().removeGroup(group.getId());
                }
            } else {
                DeluxeUtil.sms(player, ChatColor.RED + argPlayer.getName() + " is not in a group.");
            }
        } else {
            OfflinePlayer offPlayer;
            try {
                offPlayer = Bukkit.getOfflinePlayer(DeluxeUtil.asUUID(args[1]));
            } catch (Exception ex) {
                offPlayer = null;
            }
            if (offPlayer != null) {
                if (DeluxeGroups.getDatabase().inGroup(argPlayer.getUniqueId().toString())) {
                    DeluxeGroup group = DeluxeGroups.getDatabase().getPlayerGroup(argPlayer.getUniqueId().toString());
                    DeluxeGroups.getDatabase().removePlayer(argPlayer.getUniqueId().toString());
                    DeluxeUtil.sms(player, ChatColor.GREEN + offPlayer.getName() + " was kicked from " + group.getName() + ".");
                    if (offPlayer.isOnline()) {
                        Player onPlayer = Bukkit.getPlayer(offPlayer.getUniqueId());
                        DeluxeUtil.sms(onPlayer, ChatColor.RED + "You were kicked from " + group.getName() + ".");
                    }
                } else {
                    DeluxeUtil.sms(player, ChatColor.RED + offPlayer.getName() + " is not in a group.");
                }
            } else {
                DeluxeUtil.sms(player, ChatColor.RED + "Player not found.");
            }
        }
    }

    public static void help(Player player) {
        StringBuilder message = new StringBuilder(ChatColor.GOLD + "===== Group Help =====");
        for (Usage usage : Usage.values()) {
            if (usage.canUse(player)) {
                message.append("\n" + ChatColor.GREEN + usage.getFullUsage(player));
            }
        }
        DeluxeUtil.sms(player, message.toString());
    }

    enum Usage {

        CREATE("/group create <group name> [<password> <confirm password>]"),
        JOIN("/group join <group name> [<password>]"),
        LEAVE("/group leave"),
        LIST("/group list [<group name>]", "deluxegroups.admin", "/group list"),
        PASSWORD("/group password <group name> [<new password> <confirm password>]", "deluxegroups.admin"),
        PERMANENT("/group permanent <group name> <true|false>", "deluxegroups.admin"),
        KICK("/group kick <player name or UUID>", "deluxegroups.admin");

        private String usage;
        private String permission;
        private String alternate;

        Usage(String usage) {
            this.usage = usage;
            this.permission = null;
            this.alternate = null;
        }

        Usage(String usage, String permission) {
            this.usage = usage;
            this.permission = permission;
            this.alternate = null;
        }

        Usage(String usage, String permission, String alternate) {
            this.usage = usage;
            this.permission = permission;
            this.alternate = alternate;
        }

        public String getUsage() {
            return usage;
        }

        public String getPermission() {
            return permission;
        }

        public String getAlternate() {
            return alternate;
        }

        public boolean canUse(Player player) {
            return permission == null || player.hasPermission(permission);
        }

        public String getFullUsage(Player player) {
            return (permission == null || player.hasPermission(permission)) ? usage : alternate;
        }
    }
}