LibsDisguises/src/me/libraryaddict/disguise/commands/DisguiseHelpCommand.java

package me.libraryaddict.disguise.commands;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;

import me.libraryaddict.disguise.disguisetypes.AnimalColor;
import me.libraryaddict.disguise.disguisetypes.DisguiseType;
import me.libraryaddict.disguise.disguisetypes.FlagWatcher;
import me.libraryaddict.disguise.disguisetypes.watchers.LivingWatcher;
import me.libraryaddict.disguise.utilities.BaseDisguiseCommand;

import org.apache.commons.lang.StringUtils;
import org.bukkit.ChatColor;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.inventory.ItemStack;
import org.bukkit.potion.PotionEffectType;

public class DisguiseHelpCommand extends BaseDisguiseCommand {
    private class EnumHelp {
        private String enumDescription;
        private String enumName;
        private String[] enums;
        private String readableEnum;

        public EnumHelp(String enumName, String enumReadable, String enumDescription, Enum[] enums) {
            String[] strings = new String[enums.length];
            for (int i = 0; i < strings.length; i++) {
                strings[i] = toReadable(enums[i].name());
            }
            this.enumName = enumName;
            this.enumDescription = enumDescription;
            this.enums = strings;
            this.readableEnum = enumReadable;
        }

        public EnumHelp(String enumName, String enumReadable, String enumDescription, String[] enums) {
            this.enumName = enumName;
            this.enumDescription = enumDescription;
            this.enums = enums;
            this.readableEnum = enumReadable;
        }

        public String getEnumDescription() {
            return enumDescription;
        }

        public String getEnumName() {
            return enumName;
        }

        public String[] getEnums() {
            return enums;
        }

        public String getReadableEnum() {
            return readableEnum;
        }
    }

    private ArrayList<EnumHelp> enumHelp = new ArrayList<EnumHelp>();

    public DisguiseHelpCommand() {
        try {
            enumHelp.add(new EnumHelp("AnimalColor", "Animal colors", ChatColor.RED + "/disguisehelp AnimalColors "
                    + ChatColor.GREEN + "- View all the colors you can use for a animal color", AnimalColor.values()));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        try {
            enumHelp.add(new EnumHelp("Art", "Arts", ChatColor.RED + "/disguisehelp Art " + ChatColor.GREEN
                    + "- View all the painting arts you can use on a painting disguise", (Enum[]) Class.forName("org.bukkit.Art")
                    .getEnumConstants()));
        } catch (Exception ex) {
        }
        try {
            enumHelp.add(new EnumHelp("HorseColor", "Horse colors", ChatColor.RED + "/disguisehelp HorseColors "
                    + ChatColor.GREEN + "- View all the colors you can use for a horses color", (Enum[]) Class.forName(
                    "org.bukkit.entity.Horse$Color").getEnumConstants()));
        } catch (Exception ex) {
        }
        try {
            enumHelp.add(new EnumHelp("HorseStyle", "Horse styles", ChatColor.RED + "/disguisehelp HorseStyles "
                    + ChatColor.GREEN + "- View all the styles you can use for a horses style", (Enum[]) Class.forName(
                    "org.bukkit.entity.Horse$Style").getEnumConstants()));
        } catch (Exception ex) {
        }
        try {
            enumHelp.add(new EnumHelp("OcelotType", "Ocelot types", ChatColor.RED + "/disguisehelp OcelotTypes "
                    + ChatColor.GREEN + "- View all the ocelot types you can use for ocelots", (Enum[]) Class.forName(
                    "org.bukkit.entity.Ocelot$Type").getEnumConstants()));
        } catch (Exception ex) {
        }
        try {
            ArrayList<String> enumReturns = new ArrayList<String>();
            for (PotionEffectType potionType : PotionEffectType.values()) {
                if (potionType != null)
                    enumReturns.add(toReadable(potionType.getName()) + ChatColor.RED + "(" + ChatColor.GREEN + potionType.getId()
                            + ChatColor.RED + ")");
            }
            enumHelp.add(new EnumHelp("PotionEffect", "PotionEffect", ChatColor.RED + "/disguisehelp PotionEffect "
                    + ChatColor.GREEN + "- View all the potion effects you can set", enumReturns.toArray(new String[enumReturns
                    .size()])));
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        try {
            enumHelp.add(new EnumHelp("Profession", "Villager professions", ChatColor.RED + "/disguisehelp Professions "
                    + ChatColor.GREEN + "- View all the professions you can set on a villager", (Enum[]) Class.forName(
                    "org.bukkit.entity.Villager$Profession").getEnumConstants()));
        } catch (Exception ex) {
        }
    }

    @Override
    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
        for (String node : new String[] { "disguise", "disguiseradius", "disguiseentity", "disguiseplayer" }) {
            HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> permMap = getPermissions(sender, "libsdisguises." + node
                    + ".");
            if (!permMap.isEmpty()) {
                if (args.length == 0) {
                    sendCommandUsage(sender, null);
                    return true;
                } else {
                    EnumHelp help = null;
                    for (EnumHelp s : enumHelp) {
                        if (args[0].equalsIgnoreCase(s.getEnumName()) || args[0].equalsIgnoreCase(s.getEnumName() + "s")) {
                            help = s;
                            break;
                        }
                    }
                    if (help != null) {
                        sender.sendMessage(ChatColor.RED + help.getReadableEnum() + ": " + ChatColor.GREEN
                                + StringUtils.join(help.getEnums(), ChatColor.RED + ", " + ChatColor.GREEN));
                        return true;
                    }
                    DisguiseType type = null;
                    for (DisguiseType disguiseType : DisguiseType.values()) {
                        if (args[0].equalsIgnoreCase(disguiseType.name())
                                || disguiseType.name().replace("_", "").equalsIgnoreCase(args[0])) {
                            type = disguiseType;
                            break;
                        }
                    }
                    if (type == null) {
                        sender.sendMessage(ChatColor.RED + "Cannot find the disguise " + args[0]);
                        return true;
                    }
                    if (!permMap.containsKey(type)) {
                        sender.sendMessage(ChatColor.RED + "You do not have permission for that disguise!");
                        return true;
                    }
                    ArrayList<String> methods = new ArrayList<String>();
                    HashMap<String, ChatColor> map = new HashMap<String, ChatColor>();
                    Class watcher = type.getWatcherClass();
                    int ignored = 0;
                    try {
                        for (Method method : this.getDisguiseWatcherMethods(watcher)) {
                            if (!method.getName().startsWith("get") && method.getParameterTypes().length == 1
                                    && method.getAnnotation(Deprecated.class) == null) {
                                if (args.length < 2 || !args[1].equalsIgnoreCase("show")) {
                                    boolean allowed = false;
                                    for (ArrayList<String> key : permMap.get(type).keySet()) {
                                        if (permMap.get(type).get(key)) {
                                            if (key.contains("*") || key.contains(method.getName().toLowerCase())) {
                                                allowed = true;
                                                break;
                                            }
                                        } else if (!key.contains(method.getName().toLowerCase())) {
                                            allowed = true;
                                            break;
                                        }
                                    }
                                    if (!allowed) {
                                        ignored++;
                                        continue;
                                    }
                                }
                                Class c = method.getParameterTypes()[0];
                                String valueType = null;
                                if (c == String.class) {
                                    valueType = "String";
                                } else if (boolean.class == c) {
                                    valueType = "True/False";
                                } else if (int.class == c) {
                                    valueType = "Number";
                                } else if (float.class == c || double.class == c) {
                                    valueType = "Decimal";
                                } else if (AnimalColor.class == c) {
                                    valueType = "Color";
                                } else if (ItemStack.class == c) {
                                    valueType = "Item (id:damage)";
                                } else if (ItemStack[].class == c) {
                                    valueType = "4 items (id:damage,id,...)";
                                } else if (c.getSimpleName().equals("Style")) {
                                    valueType = "Horse Style";
                                } else if (c.getSimpleName().equals("Color")) {
                                    valueType = "Horse Color";
                                } else if (c.getSimpleName().equals("Type")) {
                                    valueType = "Ocelot type";
                                } else if (c.getSimpleName().equals("Profession")) {
                                    valueType = "Villager Profession";
                                } else if (PotionEffectType.class == c) {
                                    valueType = "Potion effect";
                                } else if (c == int[].class) {
                                    valueType = "number,number,number...";
                                }
                                if (valueType != null) {
                                    ChatColor methodColor = ChatColor.YELLOW;
                                    Class<?> declaring = method.getDeclaringClass();
                                    if (declaring == LivingWatcher.class) {
                                        methodColor = ChatColor.AQUA;
                                    } else if (!(declaring.isAssignableFrom(FlagWatcher.class)) || declaring == FlagWatcher.class) {
                                        methodColor = ChatColor.GRAY;
                                    }
                                    String str = method.getName() + ChatColor.DARK_RED + "(" + ChatColor.GREEN + valueType
                                            + ChatColor.DARK_RED + ")";
                                    map.put(str, methodColor);
                                    methods.add(str);
                                }
                            }
                        }
                    } catch (Exception ex) {
                        ex.printStackTrace();
                    }
                    Collections.sort(methods, String.CASE_INSENSITIVE_ORDER);
                    for (int i = 0; i < methods.size(); i++) {
                        methods.set(i, map.get(methods.get(i)) + methods.get(i));
                    }
                    if (methods.isEmpty()) {
                        methods.add(ChatColor.RED + "No options with permission to use");
                    }
                    sender.sendMessage(ChatColor.DARK_RED + type.toReadable() + " options: "
                            + StringUtils.join(methods, ChatColor.DARK_RED + ", "));
                    if (ignored > 0) {
                        sender.sendMessage(ChatColor.RED + "Ignored " + ignored
                                + " options you do not have permission to view. Add 'show' to view unusable options.");
                    }
                    return true;
                }
            }
        }
        sender.sendMessage(ChatColor.RED + "You are forbidden to use this command.");
        return true;
    }

    /**
     * Send the player the information
     */
    protected void sendCommandUsage(CommandSender sender, HashMap<DisguiseType, HashMap<ArrayList<String>, Boolean>> map) {
        sender.sendMessage(ChatColor.RED
                + "/disguisehelp <DisguiseType> "
                + ChatColor.GREEN
                + "- View the options you can set on a disguise. Add 'show' to reveal the options you don't have permission to use");
        for (EnumHelp s : enumHelp) {
            sender.sendMessage(s.getEnumDescription());
        }
    }

    public String toReadable(String string) {
        String[] split = string.split("_");
        for (int i = 0; i < split.length; i++)
            split[i] = split[i].substring(0, 1) + split[i].substring(1).toLowerCase();
        return StringUtils.join(split, "_");
    }
}